The wasm-encoder Reference Manual
Table of Contents
The wasm-encoder Reference Manual
This is the wasm-encoder Reference Manual, version 0.2,
generated automatically by Declt version 3.0 "Montgomery Scott"
on Sun May 15 06:26:51 2022 GMT+0.
1 Introduction
= WASM-ENCODER =
:AUTHOR: Alexander Gutev
:EMAIL:
:toc: preamble
:toclevels: 4
:icons: font
:idprefix:
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:caution-caption: :fire:
:important-caption: :exclamation:
:warning-caption: :warning:
endif::[]
This is a simple library for serializing a representation of
WebAssembly modules to the binary wasm format.
== Documentation ==
[[value_types]]
=== Value Types ===
The value types of various entities, such as global variables,
function arguments and return values, local and global variables, are
identified by the following symbols:
.Numeric Types
`I32`:: 32-bit integer
`I64`:: 64-bit integer
`F32`:: 32-bit single precision floating point value
`F64`:: 64-bit double precision floating point value
.Reference Types
`FUNCREF`:: Function reference
`EXTERNREF`:: All reference objects that can be passed to WebAssembly
NOTE: A symbol is considered equivalent to one of the above if its
symbol name is equivalent, regardless of its package. Thus you don't
have to import `I32`, etc from the `WASM-ENCODER` package.
=== Instructions ===
A WebAssembly instruction is represented by a symbol of which the
symbol name is equal to the instruction's mnemonic. Any symbol, in any
package, with a symbol name that is equal to a WebAssembly instruction
mnemonic can be used.
Instructions which accept static options are represented by a list in
which the first element (the `CAR`) is the instruction mnemonic and
the remaining elements are the options. The interpretation of the
options depends on the instruction.
==== Branch Instructions ====
The `BR` and `BR_IF` branch instructions each take a single option, an
unsigned integer interpreted as the index of the block which is the
branch target.
The `BR_TABLE` takes a variable number of options, where each option
is an unsigned integer, interpreted as a block index.
.Examples
--------------------------------------------------
(BR 0) ;; Branch to block 0
(BR_IF 2) ;; Branch to block 2
(BR_TABLE 0 1 2)
--------------------------------------------------
==== Call Instructions ====
The `CALL` instruction takes a single option, an unsigned integer
interpreted as the index of the function being called.
The `CALL_INDIRECT` instruction takes a single option, an unsigned
integer interpreted as the index, within the type section, of the
function's type signature.
.Examples
--------------------------------------------------
(CALL 5) ;; Call function 5
(CALL_INDIRECT 2) ;; Indirect call to a function with type signature index 2
--------------------------------------------------
==== Select Instruction ====
The select instruction takes an optional list of type identifier which
represent the value types of the operands to be selected. If there is
more than one type specifier then there is more than one value per
operand.
.Example
--------------------------------------------------
(select f32 f64)
--------------------------------------------------
In the above example `SELECT` consumes, off the stack, two operands,
following the condition, each consisting of two values the first being
an `F32` and the second being an `F64`. The two values of the result
operand, of type `F32` and `F64`, are pushed back onto the stack.
If `SELECT` is not given the type identifier of it's operand values,
the operands must be of a numeric type.
NOTE: In the current version of WebAssembly `SELECT` may only specify
a single value type, for a single value per operand. This library
supports `SELECT` with multiple operand value types.
==== Local and Global Variable Instructions ====
The instructions for retrieving/setting the value of a local/global
variable, each take a single options, an unsigned integer interpreted
as the local/global variable index.
- `LOCAL.GET`
- `LOCAL.SET`
- `LOCAL.TEE`
- `GLOBAL.GET`
- `GLOBAL.SET`
==== Memory Instructions ====
Memory load/store instructions take an optional list specifying the
expected alignment and offset. These operands take the following form:
--------------------------------------------------
(I32.STORE (ALIGN a) (OFFSET o)) ;; Alignment = a, Offset = o
--------------------------------------------------
The alignment option is a list of two elements where the first element
is a symbol, with name `ALIGN`, and the second element is an unsigned
integer specifying the alignment as a power of two. If the alignment
option is omitted a default alignment of `2` is assumed.
The offset option is a list of two elements where the first element is
a symbol, with name `OFFSET`, and the second element is an unsigned
integer specifying the offset. If this option is omitted a default
offset of `0` is assumed.
TIP: As with the instruction mnemonics any symbol, in any package,
with symbol name `ALIGN` or `OFFSET` can be used to specify the
alignment and offset options.
The alignment and offset options can be specified in any order and
either one, or both, can be omitted. If both options are omitted the
instruction can either take the form of a list containing only the
instruction mnemonic, or the instruction mnemonic symbol by itself.
.Examples:
--------------------------------------------------
(I32.LOAD (OFFSET 8)) ;; Offset = 8
(I32.STORE (ALIGN 1)) ;; Alignment = 1
I64.STORE ;; Default Alignment = 2 and Offset = 0
--------------------------------------------------
The instructions falling within this group are all the typed `xx.LOAD`
and `xx.STORE` instructions (where `xx` is the value type), including
the instructions with a storage size which is smaller than the size of
the type.
==== Constant Instructions ====
Constant instructions take a single option which is the literal
constant value.
- `I32.CONST` and `I64.CONST` take either a signed or unsigned 32-bit
(64-bit in the case of `I64.CONST`) integer option. However,
regardless of whether the operand value is signed or not, the value
itself is always encoded as a signed integer in twos-complement.
- `F32.CONST` takes a single precision floating-point
(`SINGLE-FLOAT`) value as its option.
- `F64.CONST` takes either a single or double precision floating-point
value as its option.
==== Reference Instructions ====
The `REF.NULL` instruction takes a single option which is interpreted
as the reference type identifier, either `FUNCREF` or `EXTERNREF`. See
<>.
The `REF.FUNC` instruction takes a single option, an unsigned integer
interpreted as the index of the function, within the function section,
to which to return a reference.
==== Memory and Table Instructions ====
The `MEMORY.INIT` and `DATA.DROP` instructions both take a single
option, an unsigned integer which is interpreted as the index of a
data segment within the data section.
The `TABLE.INIT` and `TABLE.COPY` instructions take two options, both
unsigned integers which are interpreted as a table index and element
segment index.
The `ELEM.DROP` instruction takes a single instruction, an unsigned
integer interpreted as an element segment index.
The `TABLE.GET`, `TABLE.SET`, `TABLE.SIZE`, `TABLE.GROW` and
`TABLE.FILL` instructions each take a single option, an unsigned
integer interpreted as a table index.
==== Structured Block Instructions ====
Structured block instructions are represented by a list with the block
type in the first element being and the instructions, comprising the
body of the block, in the remaining elements.
The second element of the list may be either an instruction, in which
case it is the first instruction of the block, or one of the
following:
`(RESULT type)`:: Indicates the type of value returned (on the stack)
by the block, where `type` is the value type identifier, see
<>.
`(TYPE index)`:: Indicates the of the values consumed (from the stack)
and returned by the block, where `index` is the index of a function
type specifier, with the type section, see <>.
If neither a result type nor type signature is specified, then it is
assumed that the block neither consumes nor returns a value and hence
does not have a return value type.
The `BLOCK` and `LOOP` block instructions follow this representation
exactly.
.Example: Simple block (no result type)
--------------------------------------------------
(block
(local.get 1)
(br_if 0)
(call 0))
--------------------------------------------------
.Example: Block with result type
--------------------------------------------------
(block (result i32)
(local.get 1)
(br_if 0)
(local.get 2)
(local.get 3)
i32.add)
--------------------------------------------------
.Example: Block with type signature
--------------------------------------------------
(block (type 1) ;; (i32 i32 i32) => i32
i32.add
i32.mul)
--------------------------------------------------
.Example: Simple loop
--------------------------------------------------
(loop
(call 0)
(local.get 1)
(i32.const 5)
i32.lt
(br_if 0))
--------------------------------------------------
The `IF` instruction is represented by a list of the following form:
--------------------------------------------------
(IF (THEN instructions...)
(ELSE instructions...))
--------------------------------------------------
Where `instructions` are the instructions comprising the body of the
`THEN` and `ELSE` branches. The `(ELSE ...)` element may be omitted in
which case the if instruction does not have an else branch.
The `IF` instruction may also have an optional result type or type
signature specified in the second element by `(RESULT type)` or `(TYPE
index)`. If this is omitted the `IF` instruction is assumed to have no
result type.
.Example: If without else branch
--------------------------------------------------
(local.get 0)
(if (then (call 0))
--------------------------------------------------
.Example: If with else branch
--------------------------------------------------
(local.get 0)
(if (then (call 0))
(else (call 1)))
--------------------------------------------------
.Example: If with result type
--------------------------------------------------
(local.get 0)
(i32.const 0)
i32.ge
(if (result i32)
(then (local.get 0))
(else (local.get 0)
(i32.const -1)
i32.mul))
--------------------------------------------------
=== Modules ===
A WebAssembly module is represented by the `WASM-MODULE` structure,
which contains a slot for each section. A `WASM-MODULE` object can be
serialized to an output stream using the `SERIALIZE-MODULE` function.
==== WASM-MODULE ====
Structure: `WASM-MODULE`
Represents a WebAssembly module with a lot for each section:
Slots:
- `TYPES`
- `IMPORTS`
- `FUNCTIONS`
- `TABLES`
- `MEMORY`
- `GLOBALS`
- `EXPORTS`
- `START`
- `ELEMENTS`
- `DATA`
==== SERIALIZE-MODULE ====
Function: `SERIALIZE-MODULE MODULE STREAM`
Serialize a module to the wasm binary format and write the output to a
given stream.
`MODULE`:: The `WASM-MODULE` to serialize.
`STREAM`:: Output stream to which to serialize the module. This must
be a binary output stream with element type `(UNSIGNED-BYTE 8)`.
[[type_section]]
=== Type Section ===
The `TYPES` slot, of `WASM-MODULE` ,is a list of `WASM-FUNCTION-TYPE`
objects which represent the function type signatures of the module's
functions.
==== WASM-FUNCTION-TYPE ====
Structure: `WASM-FUNCTION-TYPE`
Represents a function type signature.
Slots:
`PARAMS`:: List of the argument types
`RESULTS`:: List of the return value types
=== Imports Section ===
The `IMPORTS` slot, of `WASM-MODULE`, is a list of `WASM-IMPORT`
objects which represent the module's imports.
[[wasm_import]]
==== WASM-IMPORT ====
Structure: `WASM-IMPORT`
Represents an imported entity.
Slots:
`MODULE`:: Module component (first level) of the import name
`NAME`:: Name component (second level) of the import name
`TYPE`:: Keyword identifying type of imported entity:
+
--
`:FUNC`:: The imported entity is a function
`:TABLE`:: The imported entity is a table object
`:MEMORY`:: The imported entity is a memory object
`:GLOBAL`:: The imported entity is a global variable
--
`DESC`:: Description of the imported entity, which depends on `TYPE`:
+
--
`:FUNC`:: Index of the function's type signature within the module's
type section.
`:TABLE`:: A `WASM-TABLE` object specifying the table type and limits.
`:MEMORY`:: A `WASM-LIMIT` object specifying the memory limits.
`:GLOBAL`:: A list of the form `(TYPE MUTABLE-P)` where `TYPE` is the
value type of the variable and `MUTABLE-P` is a flag, which if true,
indicates that the variable is mutable.
--
=== Functions ===
The slot `FUNCTIONS`, of `WASM-MODULE`, is a list of `WASM-FUNCTION`
objects which represent the module's functions.
==== WASM-FUNCTION ====
Structure: `WASM-FUNCTION`
Represents a function.
Slots:
`TYPE`:: Index of the function's type signature within the type section.
`LOCALS`:: List of the types of the local variables.
`CODE`:: List of instructions comprising the body of the function.
=== Memory and Table Sections ===
The `MEMORY` slot is a list of `WASM-LIMIT` objects which specify the
limits of the module's memory objects.
The slot `TABLES`, of `WASM-MODULE`, is a list of `WASM-TABLE` objects
which specify the type and limits of the module's table objects.
NOTE: In the current version of WebAssembly, modules may contain a
maximum of one table and memory object. This library supports
serializing modules with more than one memory and table object.
==== WASM-LIMIT ====
Structure: `WASM-LIMIT`
Specifies the limits of a memory and table objects.
Slots:
`MIN`:: The lower-bound of the memory / table limit. Must be greater
than or equal to 0.
`MAX`:: The upper-bound of the limit. If NIL the limit has no
upper-bound.
==== WASM-TABLE ====
Structure: `WASM-TABLE (:INCLUDE WASM-LIMIT)`
Specifies the type and limits of a table object. Includes the slots of
the structure `WASM-LIMIT`.
Slots:
`TYPE`:: Table element type, either `FUNCREF` (the default) or `EXTERNREF`.
NOTE: In the current version of WebAssembly only tables of type
`FUNCREF` are supported.
=== Global Variable Section ===
The `GLOBALS` slot, of `WASM-MODULE`, is a list of `WASM-GLOBAL`
objects which represent the module's global variables.
==== WASM-GLOBAL ====
Structure: `WASM-GLOBAL`
Represents a global variable
.Slots
`TYPE`:: Value type of the variable.
`MUTABLE-P`:: Flag, which if true, indicates the variable is
mutable. Otherwise the variable is immutable.
`INIT`:: Expression which computes the variable's initial value. May
be `NIL`.
=== Exports Section ===
The `EXPORTS` slot, of `WASM-MODULE`, is a list of `WASM-EXPORT`
objects which represent the entities exported by the module.
==== WASM-EXPORT ====
Structure: `WASM-EXPORT`
Represents an exported entity.
.Slots
`NAME`:: The name (as a string) under which the entity is exported.
`TYPE`:: Keyword describing the type of entity. See the `TYPE` slot of
<>.
`INDEX`:: Index of the exported entity within its sections.
=== Start Function ===
The `START` slot, of `WASM-MODULE`, is the index of the function, with
functions list in the `FUNCTIONS` slot, of the function which serves
as the module's entry point. If `NIL` the module does not have an
entry point.
=== Element Section ===
The `ELEMENTS` slot, of `WASM-MODULE`, is a list of `WASM-ELEMENT`
objects which represent the module's element segments.
Each element segment specifies the initial values of a range of
elements in a table object.
==== WASM-ELEMENT ====
Structure `WASM-ELEMENT`
Represents an element segment.
.Slots
`MODE`:: Keyword specifying the element segment mode.
+
--
`:ACTIVE`:: An 'active' segment , which is used to initialize the
table elements during module instantiation. This is the default.
`:PASSIVE`:: A 'passive' segment, which can be used to initialize the
table elements at runtime with the `TABLE.INIT` instruction.
`:DECLARATIVE`:: A 'declarative' segment, which is used only to
forward declare the function references that will be added to the
table, using the `REF.FUNC` instruction.
--
`INDEX`:: Index of the table object, 0 by default, which this element
initializes. This slot is only used when `MODE` is `:ACTIVE`.
+
--
NOTE: In the current version of WebAssembly the only valid index is 0.
--
`OFFSET`:: Expression which computes the starting index of the
location within the table where the elements in this segment are
copied to.
`INIT`:: Object specifying the values of the elements in this
segment. This can be either a `WASM-ELEMENT-INIT-INDEX` or
`WASM-ELEMENT-INIT-EXPRESSIONS` object.
==== WASM-ELEMENT-INIT-INDEX ====
Structure `WASM-ELEMENT-INIT-INDEX`
Represents a table element segment where the initial element values
are function indices.
.Slots
`FUNCTIONS`:: List of indices of the functions, within the function
section (`FUNCTIONs` slot), to which the table elements are set.
==== WASM-ELEMENT-INIT-EXPRESSIONS ====
Structure `WASM-ELEMENT-INIT-EXPRESSIONS`
Represents a table element segment where the initial element values
are computed by expressions.
.Slots
`TYPE`:: Table element type, either `FUNCREF` (default) or
`EXTERNREF`.
`EXPRESSIONS`:: List of expressions which compute the initial element
values. Each expression should leave a function reference on the
stack, which is obtained with the `REF.FUNC` instruction.
=== Data Section ===
The `DATA` slot, of `WASM-MODULE`, is a list of `WASM-DATA` objects
which represent the module's data segments.
Each data segment specifies the initial values of a range of bytes
in a memory object.
==== WASM-DATA ====
Structure `WASM-DATA`
Represents a data segment.
.Slots
`MODE`:: Keyword specifying the element segment mode.
+
--
`:ACTIVE`:: An 'active' segment, which is used to initialize the
memory object during module instantiation. This is the default.
`:PASSIVE`:: A 'passive' segment, which can be used to initialize the
memory object at runtime with the `MEMORY.INIT` instruction.
--
`MEMORY`:: Index of the memory object, 0 by default, which this element
initializes. This slot is only used when `MODE` is `:ACTIVE`.
+
--
NOTE: In the current version of WebAssembly the only valid index is 0.
--
`OFFSET`:: Expression which computes the starting index of the
location within the memory object where the bytes in this segment are
copied to.
`BYTES`:: Byte array containing the values to which the bytes in the
memory object are set.
2 Systems
The main system appears first, followed by any subsystem dependency.
2.1 wasm-encoder
- Author
Alexander Gutev <alex.gutev@mail.bg>
- License
MIT
- Description
Library for serializing WebAssembly modules to binary .wasm files
- Version
0.2
- Dependencies
- generic-cl
- agutil
- alexandria
- trivia
- ieee-floats
- babel
- flexi-streams
- Source
wasm-encoder.asd (file)
- Component
src (module)
3 Modules
Modules are listed depth-first from the system components tree.
3.1 wasm-encoder/src
- Parent
wasm-encoder (system)
- Location
src/
- Components
-
4 Files
Files are sorted by type and then listed depth-first from the systems
components trees.
4.1 Lisp
4.1.1 wasm-encoder.asd
- Location
wasm-encoder.asd
- Systems
wasm-encoder (system)
4.1.2 wasm-encoder/src/package.lisp
- Parent
src (module)
- Location
src/package.lisp
- Packages
wasm-encoder
4.1.3 wasm-encoder/src/wasm-encoder.lisp
- Dependency
package.lisp (file)
- Parent
src (module)
- Location
src/wasm-encoder.lisp
- Exported Definitions
-
- Internal Definitions
-
5 Packages
Packages are listed by definition order.
5.1 wasm-encoder
- Source
package.lisp (file)
- Use List
- babel-encodings
- babel
- ieee-floats
- trivia.level2
- alexandria
- agutil
- generic-cl
- Exported Definitions
-
- Internal Definitions
-
6 Definitions
Definitions are sorted by export status, category, package, and then by
lexicographic order.
6.1 Exported definitions
6.1.1 Functions
- Function: make-wasm-data &key (MODE MODE) (OFFSET OFFSET) (BYTES BYTES) (MEMORY MEMORY)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-element &key (MODE MODE) (INDEX INDEX) (OFFSET OFFSET) (INIT INIT)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-element-init-expressions &key (TYPE TYPE) (EXPRESSIONS EXPRESSIONS)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-element-init-index &key (FUNCTIONS FUNCTIONS)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-export &key (NAME NAME) (TYPE TYPE) (INDEX INDEX)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-function &key (TYPE TYPE) (LOCALS LOCALS) (CODE CODE)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-function-type &key (PARAMS PARAMS) (RESULTS RESULTS)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-global &key (TYPE TYPE) (MUTABLE-P MUTABLE-P) (INIT INIT)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-import &key (MODULE MODULE) (NAME NAME) (TYPE TYPE) (DESC DESC)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-limit &key (MIN MIN) (MAX MAX)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-module &key (TYPES TYPES) (IMPORTS IMPORTS) (FUNCTIONS FUNCTIONS) (TABLES TABLES) (MEMORY MEMORY) (GLOBALS GLOBALS) (EXPORTS EXPORTS) (START START) (ELEMENTS ELEMENTS) (DATA DATA) (DATA-COUNT DATA-COUNT)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: make-wasm-table &key (MIN MIN) (MAX MAX) (TYPE TYPE)
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-module MODULE STREAM
-
Serialize a WebAssembly module to an output stream.
MODULE is a ‘WASM-MODULE’ object.
STREAM is the output stream, which must be a binary stream with
element type (unsigned-byte 8).
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-data-bytes INSTANCE
-
- Function: (setf wasm-data-bytes) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-data-memory INSTANCE
-
- Function: (setf wasm-data-memory) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-data-mode INSTANCE
-
- Function: (setf wasm-data-mode) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-data-offset INSTANCE
-
- Function: (setf wasm-data-offset) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-data-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-index INSTANCE
-
- Function: (setf wasm-element-index) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-init INSTANCE
-
- Function: (setf wasm-element-init) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-init-expressions-expressions INSTANCE
-
- Function: (setf wasm-element-init-expressions-expressions) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-init-expressions-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-init-index-functions INSTANCE
-
- Function: (setf wasm-element-init-index-functions) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-init-index-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-mode INSTANCE
-
- Function: (setf wasm-element-mode) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-offset INSTANCE
-
- Function: (setf wasm-element-offset) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-export-index INSTANCE
-
- Function: (setf wasm-export-index) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-export-name INSTANCE
-
- Function: (setf wasm-export-name) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-export-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-export-type INSTANCE
-
- Function: (setf wasm-export-type) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-function-code INSTANCE
-
- Function: (setf wasm-function-code) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-function-locals INSTANCE
-
- Function: (setf wasm-function-locals) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-function-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-function-type INSTANCE
-
- Function: (setf wasm-function-type) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-function-type-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-function-type-params INSTANCE
-
- Function: (setf wasm-function-type-params) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-function-type-results INSTANCE
-
- Function: (setf wasm-function-type-results) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-global-init INSTANCE
-
- Function: (setf wasm-global-init) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-global-mutable-p INSTANCE
-
- Function: (setf wasm-global-mutable-p) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-global-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-global-type INSTANCE
-
- Function: (setf wasm-global-type) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-import-desc INSTANCE
-
- Function: (setf wasm-import-desc) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-import-module INSTANCE
-
- Function: (setf wasm-import-module) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-import-name INSTANCE
-
- Function: (setf wasm-import-name) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-import-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-import-type INSTANCE
-
- Function: (setf wasm-import-type) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-limit-max INSTANCE
-
- Function: (setf wasm-limit-max) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-limit-min INSTANCE
-
- Function: (setf wasm-limit-min) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-limit-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-data INSTANCE
-
- Function: (setf wasm-module-data) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-data-count INSTANCE
-
- Function: (setf wasm-module-data-count) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-elements INSTANCE
-
- Function: (setf wasm-module-elements) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-exports INSTANCE
-
- Function: (setf wasm-module-exports) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-functions INSTANCE
-
- Function: (setf wasm-module-functions) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-globals INSTANCE
-
- Function: (setf wasm-module-globals) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-imports INSTANCE
-
- Function: (setf wasm-module-imports) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-memory INSTANCE
-
- Function: (setf wasm-module-memory) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-start INSTANCE
-
- Function: (setf wasm-module-start) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-types INSTANCE
-
- Function: (setf wasm-module-types) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-table-max INSTANCE
-
- Function: (setf wasm-table-max) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-table-min INSTANCE
-
- Function: (setf wasm-table-min) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-table-p OBJECT
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-table-type INSTANCE
-
- Function: (setf wasm-table-type) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
6.1.2 Structures
- Structure: wasm-data ()
-
Represents a data segment.
Data segments specify the initial values of memory objects.
MODE is a keyword specifying the data segment mode:
:ACTIVE - An active element initialized on module loading (the default)
:PASSIVE - A passive element which can be used with MEMORY.INIT
MEMORY is the index of the memory object to initialize. This field
is only used when MODE is :ACTIVE. By default this is 0, which is
the only valid index in the current version of WebAssembly.
OFFSET is an expression (list of instructions) which compute the
starting index of the range to initialize. This field is only used
when MODE is :ACTIVE.
BYTES is the byte array containing the values to which the bytes,
starting at OFFSET (in the case of an active data segment), are
initialized.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: mode
-
- Initform
:active
- Readers
wasm-data-mode (function)
- Writers
(setf wasm-data-mode) (function)
- Slot: offset
-
- Readers
wasm-data-offset (function)
- Writers
(setf wasm-data-offset) (function)
- Slot: bytes
-
- Readers
wasm-data-bytes (function)
- Writers
(setf wasm-data-bytes) (function)
- Slot: memory
-
- Initform
0
- Readers
wasm-data-memory (function)
- Writers
(setf wasm-data-memory) (function)
- Structure: wasm-element ()
-
Represents an element segment.
Element segments specify the initial values of table elements.
MODE is a keyword specifying the element segment mode:
:ACTIVE - An active element initialized on instantiation (the default)
:PASSIVE - A passive element which can be used with TABLE.INIT
:DECLARATIVE - A forward declaration of table contents.
INDEX is the index of the table to initialize. This slot is only
used when MODE is :ACTIVE. By default this is 0, which is the only
valid index in the current version of WebAssembly.
OFFSET is an expression (list of instructions) which compute the
starting index of the range to initialize. This field is only used
when MODE is :ACTIVE.
INIT is an object specifying the initial values of the table
elements, which can be of the following can be either a
‘WASM-ELEMENT-INIT-INDEX’ or ‘WASM-ELEMENT-INIT-EXPRESSIONS’
object.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: mode
-
- Initform
:active
- Readers
wasm-element-mode (function)
- Writers
(setf wasm-element-mode) (function)
- Slot: index
-
- Initform
0
- Readers
wasm-element-index (function)
- Writers
(setf wasm-element-index) (function)
- Slot: offset
-
- Readers
wasm-element-offset (function)
- Writers
(setf wasm-element-offset) (function)
- Slot: init
-
- Readers
wasm-element-init (function)
- Writers
(setf wasm-element-init) (function)
- Structure: wasm-element-init-expressions ()
-
Represents a table element segment initialization with expressions.
TYPE is the table element type, either FUNCREF (default) or
EXTERNREF. In the current version of WebAssembly only FUNCREF is
supported.
EXPRESSIONS is a list of expressions, where each expression is a
list of instructions, which compute the initial values of the table
elements, starting from the index OFFSET (of the WASM-ELEMENT object).
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: type
-
- Initform
(quote wasm-encoder::funcref)
- Readers
wasm-element-init-expressions-type (function)
- Writers
(setf wasm-element-init-expressions-type) (function)
- Slot: expressions
-
- Readers
wasm-element-init-expressions-expressions (function)
- Writers
(setf wasm-element-init-expressions-expressions) (function)
- Structure: wasm-element-init-index ()
-
Represents a table element segment initialization with function indices.
FUNCTIONS is a list of function indices to which the table elements
are initialized, starting from the index OFFSET (of the WASM-ELEMENT object).
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: functions
-
- Readers
wasm-element-init-index-functions (function)
- Writers
(setf wasm-element-init-index-functions) (function)
- Structure: wasm-export ()
-
Represents an exported entity.
NAME is the name at which the entity is exported.
TYPE is a keyword specifying the kind of entity that is exported:
:FUNC - function
:TABLE - table object
:MEMORY - memory object
:GLOBAL - global variable
INDEX is the index of the exported entity within the module
section in which it is contained.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: name
-
- Readers
wasm-export-name (function)
- Writers
(setf wasm-export-name) (function)
- Slot: type
-
- Readers
wasm-export-type (function)
- Writers
(setf wasm-export-type) (function)
- Slot: index
-
- Readers
wasm-export-index (function)
- Writers
(setf wasm-export-index) (function)
- Structure: wasm-function ()
-
Represents a WebAssembly function.
TYPE is the index of the functions type signature, within the type
section.
LOCALS is the list of the value types of the functions local
variables.
CODE is the list of instructions comprising the function.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: type
-
- Readers
wasm-function-type (function)
- Writers
(setf wasm-function-type) (function)
- Slot: locals
-
- Readers
wasm-function-locals (function)
- Writers
(setf wasm-function-locals) (function)
- Slot: code
-
- Readers
wasm-function-code (function)
- Writers
(setf wasm-function-code) (function)
- Structure: wasm-function-type ()
-
Represents a function type signature.
PARAMS is a list of the argument types.
RESULTS is a list of the return value types.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: params
-
- Readers
wasm-function-type-params (function)
- Writers
(setf wasm-function-type-params) (function)
- Slot: results
-
- Readers
wasm-function-type-results (function)
- Writers
(setf wasm-function-type-results) (function)
- Structure: wasm-global ()
-
Represents a global variable.
TYPE is the value type of the variable.
MUTABLE-P is a flag, which if true indicates the variable is
mutable.
INIT is an optional expression (a list of instructions) which
compute the variables initial value. If NIL the variable has no
initial value.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: type
-
- Readers
wasm-global-type (function)
- Writers
(setf wasm-global-type) (function)
- Slot: mutable-p
-
- Readers
wasm-global-mutable-p (function)
- Writers
(setf wasm-global-mutable-p) (function)
- Slot: init
-
- Readers
wasm-global-init (function)
- Writers
(setf wasm-global-init) (function)
- Structure: wasm-import ()
-
Represents an imported entity.
The two-level import name is given by MODULE and NAME.
TYPE is a keyword specifying the kind of entity that is imported:
:FUNC - function
:TABLE - table object
:MEMORY - memory object
:GLOBAL - global variable
DESC is a description of the imported entity, which depends on TYPE:
:FUNC - Index of the function’s type signature within the
module’s type section.
:TABLE - A ‘WASM-TABLE’ object specifying the table type and
limits.
:MEMORY - A ‘WASM-LIMIT’ object specifying the memory limits.
:GLOBAL - A list of the form (TYPE MUTABLE-P) where TYPE is the
value type of the variable and MUTABLE-P is a flag for
whether the variable is mutable.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: module
-
- Readers
wasm-import-module (function)
- Writers
(setf wasm-import-module) (function)
- Slot: name
-
- Readers
wasm-import-name (function)
- Writers
(setf wasm-import-name) (function)
- Slot: type
-
- Readers
wasm-import-type (function)
- Writers
(setf wasm-import-type) (function)
- Slot: desc
-
- Readers
wasm-import-desc (function)
- Writers
(setf wasm-import-desc) (function)
- Structure: wasm-limit ()
-
Represents a limit of memory or table object.
MIN is the lower bound, which must be greater than or equal to 0.
MAX is the upper bound. If NIL the limit has no upper bound.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct subclasses
wasm-table (structure)
- Direct slots
- Slot: min
-
- Readers
wasm-limit-min (function)
- Writers
(setf wasm-limit-min) (function)
- Slot: max
-
- Readers
wasm-limit-max (function)
- Writers
(setf wasm-limit-max) (function)
- Structure: wasm-module ()
-
Represents a WebAssembly module that can be serialized to the binary wasm format.
Each slot contains a list of the entities comprising a particular
section of the module. The entities are serialized in the order
given in the list.
TYPES is a list of ‘WASM-FUNCTION-TYPE’ objects representing the
function type signatures of the module’s functions.
IMPORTS is a list of ‘WASM-IMPORT’ objects representing the
module’s imports.
FUNCTIONS is a list of ‘WASM-FUNCTION’ objects representing the
module’s functions, including both the signatures and code.
TABLES is a list of ‘WASM-TABLE’ objects specifying the limits, and
types, of the module’s tables. In the current version of
WebAssembly, a module may have at most one table of type FUNCREF,
however this library supports multiple tables of both type FUNCREF
and EXTERNREF.
MEMORY is a list of ‘WASM-LIMIT’ objects specifying the limits of
the module’s memory objects. Currently a module may have at most
one memory object, however this library supports multiple memory
objects.
GLOBALS is a list of ‘WASM-GLOBAL’ objects representing the
module’s global variables.
EXPORTS is a list ‘WASM-EXPORT’ objects representing the module’s
exports.
START is the index of the function serving as the module’s entry
point. If NIL the module does not have an entry point.
ELEMENTS is a list of ‘WASM-ELEMET’ objects representing the
module’s element segments, for initializing the module’s tables.
DATA is a list of ‘WASM-DATA’ objects representing the module’s
data segments for initializing the module’s memory.
DATA-COUNT is a flag, which if true, a data count section is
emitted, prior to the code section, storing the number of data
segments.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
structure-object (structure)
- Direct slots
- Slot: types
-
- Readers
wasm-module-types (function)
- Writers
(setf wasm-module-types) (function)
- Slot: imports
-
- Readers
wasm-module-imports (function)
- Writers
(setf wasm-module-imports) (function)
- Slot: functions
-
- Readers
wasm-module-functions (function)
- Writers
(setf wasm-module-functions) (function)
- Slot: tables
-
- Readers
wasm-module-tables (function)
- Writers
(setf wasm-module-tables) (function)
- Slot: memory
-
- Readers
wasm-module-memory (function)
- Writers
(setf wasm-module-memory) (function)
- Slot: globals
-
- Readers
wasm-module-globals (function)
- Writers
(setf wasm-module-globals) (function)
- Slot: exports
-
- Readers
wasm-module-exports (function)
- Writers
(setf wasm-module-exports) (function)
- Slot: start
-
- Readers
wasm-module-start (function)
- Writers
(setf wasm-module-start) (function)
- Slot: elements
-
- Readers
wasm-module-elements (function)
- Writers
(setf wasm-module-elements) (function)
- Slot: data
-
- Readers
wasm-module-data (function)
- Writers
(setf wasm-module-data) (function)
- Slot: data-count
-
- Initform
t
- Readers
wasm-module-data-count (function)
- Writers
(setf wasm-module-data-count) (function)
- Structure: wasm-table ()
-
Represents a table object type.
TYPE is the type of element stored in the table, either FUNCREF or
EXTERNREF.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Direct superclasses
wasm-limit (structure)
- Direct slots
- Slot: type
-
- Initform
(quote wasm-encoder::funcref)
- Readers
wasm-table-type (function)
- Writers
(setf wasm-table-type) (function)
6.2 Internal definitions
6.2.1 Constants
- Constant: +code-section-id+
-
Function body section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +custom-section-id+
-
Custom section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +data-count-section-id+
-
Data count section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +data-section-id+
-
Data section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +element-section-id+
-
Element section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +export-section-id+
-
Export section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +function-section-id+
-
Identifier of the section containing the types of the functions,
in the module.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +global-section-id+
-
Global variable section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +import-section-id+
-
Import section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +memory-section-id+
-
Memory section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +op-codes+
-
WebAssembly Instruction Opcode Map.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +start-section-id+
-
Module entry point section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +table-section-id+
-
Table section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Constant: +type-section-id+
-
Function type signature section identifier.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
6.2.2 Compiler macros
- Compiler Macro: serialize-instruction-operands WHOLE &optional ENV
-
A no-op on SBCL since static dispatching is handled by the compiler
transforms, rather than compiler macros.
- Package
wasm-encoder
- Source
/home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20211209-git/src/sbcl.lisp
6.2.3 Functions
- Function: copy-wasm-data INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-element INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-element-init-expressions INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-element-init-index INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-export INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-function INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-function-type INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-global INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-import INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-limit INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-module INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: copy-wasm-table INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: data-segment-type-code DATA
-
Determine the type code of a data segment.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: intern-symbol SYM
-
Intern the symbol SYM in the package WASM-ENCODER.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: intern-symbols SYMS
-
If SYMS is a symbol intern it into WASM-ENCODER. If SYMS is a list,
apply INTERN-SYMBOLS on each of element otherwise return SYMS as
is.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-32-bit VALUE STREAM
-
Serialize an integer value to 4 bytes in little endian order.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-64-bit VALUE STREAM
-
Serialize an integer value to 8 bytes in little endian order.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-block BODY STREAM
-
Serialize a structured block instruction containing the
instructions in BODY.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-branch OPERANDS STREAM
-
Serialize the branch index of a branch instruction.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-data DATA STREAM
-
Serialize a data segment.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-data-count-section COUNT STREAM
-
Serialize the data count section.
COUNT is the number of data segments.
STREAM is the output stream.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-data-section DATA STREAM
-
Serialize the data section (containing the initialization of the
module’s memory), with the memory initialization
entries (represented by WASM-DATA objects) in DATA.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-double-float VALUE STREAM
-
Serialize a DOUBLE-FLOAT to IEEE 64-bit floating point
representation.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-export EXPORT STREAM
-
Serialize a single export entry, represented as a WASM-EXPORT
object.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-export-section EXPORTS STREAM
-
Serialize the export section consisting of the entries, represented
by WASM-EXPORT objects, in EXPORTS.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-expression INSTRUCTIONS STREAM
-
Serialize a list of instructions (an expression) followed by the
block end instruction.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-float VALUE STREAM
-
Serialize a single FLOAT to IEEE 32-bit floating point
representation.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-ftype TYPE STREAM
-
Serialize a function type signature, represented by a
WASM-FUNCTION-TYPE object.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-function FUNCTION STREAM
-
Serialize the a single function, represented by a WASM-FUNCTION
object. Only the local variable types and instructions of the
function are serialized.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-function-types TYPES STREAM
-
Serialize the function type section (containing the indices of the
type signatures of the functions defined in the module), consisting
of the function type indices in TYPES.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-functions FUNCTIONS STREAM
-
Serialize the code section (containing the actual instructions
comprising the functions in the module), consisting of the
functions, represented by WASM-FUNCTION objects, in FUNCTIONS.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-global TYPE MUTABLE? STREAM
-
Serialize a global variable with value type TYPE. If MUTABLE? is
true a mutable global variable is serialized.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-global-section GLOBALS STREAM
-
Serialize the global variable section, consisting of the global
variables, represented by WASM-GLOBAL objects, in GLOBALS.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-i32 VALUE STREAM
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-import IMPORT STREAM
-
Serialize a single import entry IMPORT, represented by a
WASM-IMPORT object.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-imports IMPORTS STREAM
-
Serialize the import section, consisting of the import entries,
represented by WASM-IMPORT objects, in IMPORTS.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-instruction INSTRUCTION STREAM
-
Serialize a WebAssembly instruction to STREAM. The instruction may
either be a symbol, naming the instruction, or a list in which the
first element is the symbol naming the instruction and the
remaining elements are the instruction operands.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-instructions INSTRUCTIONS STREAM
-
Serialize the instructions, in INSTRUCTIONS, to STREAM.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-limit LIMIT STREAM
-
Serialize a memory/table limit represented by a WASM-LIMIT object.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-memory LIMIT STREAM
-
Serialize a memory object entry with limit, represented by a
WASM-LIMIT object, given by LIMIT.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-memory-instruction OPERANDS STREAM
-
Serialize the offset and alignment operands of a memory load/store
instruction.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-memory-types MEMORY STREAM
-
Serialize the memory section, consisting of a memory object for
each limit, represented as a WASM-LIMIT, given in MEMORY.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-nil-type STREAM
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-ref-type TYPE STREAM
-
Serialize a WebAssembly function reference type.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-section ID FN STREAM
-
Serialize a section, with identifier ID, to STREAM.
FN is called with a single argument – the stream to which the
contents of the section should be written. The section id and the
number of bytes are then written to STREAM followed by the bytes
written by FN.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-signed VALUE STREAM
-
Serialize a signed integer to LEB128 format
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-start-section INDEX STREAM
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-string VALUE STREAM
-
Serialize a string to a UTF-8 encoded string without BOM.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-table TABLE STREAM
-
Serialize a table object entry with limit, represented by a
WASM-LIMIT object, given by LIMIT.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-table-element TABLE STREAM
-
Serialize a single table element initialization entry, represented
by a WASM-ELEMENT object.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-table-element-init MODE INDEX INIT STREAM
-
Serialize a table element initializer.
MODE is the table element mode.
INDEX is the table index.
INIT is the table element initializer.
STREAM is the output stream
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-table-elements ELEMENTS STREAM
-
Serialize the table element section, consisting of the table
element initializations, represented by WASM-ELEMNT objects, in
ELEMENTS.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-table-types TABLES STREAM
-
Serialize the table section, consisting of a table for each table
limit, represented as a WASM-TABLE, given in TABLES.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-type TYPE STREAM
-
Serialize a WebAssembly value type.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-types TYPES STREAM
-
Serialize the function type section consisting of the function type
signatures, represented by WASM-FUNCTION-TYPE objects, in TYPES.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-u32 VALUE STREAM
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-unsigned VALUE STREAM
-
Serialize an unsigned integer to LEB128 format
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-vector FN VECTOR STREAM
-
Serialize a vector of values.
The length VECTOR is written to STREAM first, after which FN is
called on each element of the vector. FN should write each element
it is called on to the stream passed to it in the second argument
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: serialize-with-byte-size FN STREAM
-
Serialize a sequence of bytes to STREAM, preceded by the number of bytes.
FN is called with a single argument – the stream to which the
contents of the section should be written. The number of bytes is
then written to STREAM followed by the bytes written by FN.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: table-element-type-code ELEMENT
-
Return the type code for a table element.
ELEMENT is the table element.
Returns the type code as a byte.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-element-init-expressions-type INSTANCE
-
- Function: (setf wasm-element-init-expressions-type) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Function: wasm-module-tables INSTANCE
-
- Function: (setf wasm-module-tables) VALUE INSTANCE
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
6.2.4 Generic functions
- Generic Function: serialize-instruction-operands OP OPERANDS STREAM
-
Serialize the operands (OPERANDS) of the instruction OP.
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Methods
- Method: serialize-instruction-operands (OP (eql ref.func)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql ref.null)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql f64.const)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql f32.const)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.const)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.const)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql data.drop)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql memory.init)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql memory.fill)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql memory.copy)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql memory.grow)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql memory.size)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.store32)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.store16)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.store8)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.store16)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.store8)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql f64.store)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql f32.store)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.store)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.store)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.load32_u)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.load32_s)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.load16_u)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.load16_s)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.load8_u)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.load8_s)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.load16_u)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.load16_s)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.load8_u)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.load8_s)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql f64.load)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql f32.load)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i64.load)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql i32.load)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql table.fill)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql table.size)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql table.grow)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql elem.drop)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql table.copy)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql table.init)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql table.set)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql table.get)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql global.set)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql global.get)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql local.tee)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql local.set)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql local.get)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql call_indirect)) OPERANDS STREAM
-
Serialize the type signature of a call indirect instruction.
- Method: serialize-instruction-operands (OP (eql br_table)) OPERANDS STREAM
-
Serialize the branches indices of a branch table instruction.
- Method: serialize-instruction-operands (OP (eql call)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql br_if)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql br)) OPERANDS STREAM
-
- Method: serialize-instruction-operands (OP (eql if)) BODY STREAM
-
Serialize the body of an IF structured instruction.
- Method: serialize-instruction-operands (OP (eql select)) OPERANDS STREAM
-
Serialize the value types of the a select t* instruction
- Method: serialize-instruction-operands (OP (eql loop)) BODY STREAM
-
- Method: serialize-instruction-operands (OP (eql block)) BODY STREAM
-
- Method: serialize-instruction-operands OP OPERANDS STREAM
-
Default Method, does nothing.
- Generic Function: serialize-table-instruction OPERANDS STREAM
-
- Package
wasm-encoder
- Methods
- Method: serialize-table-instruction OPERANDS STREAM
-
Serialize the table index of a table instruction.
- Source
wasm-encoder.lisp (file)
- Generic Function: serialize-variable-instruction OPERANDS STREAM
-
- Package
wasm-encoder
- Methods
- Method: serialize-variable-instruction OPERANDS STREAM
-
Serialize the local variable index of a local variable
instruction.
- Source
wasm-encoder.lisp (file)
6.2.5 Types
- Type: i32 ()
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Type: i64 ()
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Type: u32 ()
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
- Type: u64 ()
-
- Package
wasm-encoder
- Source
wasm-encoder.lisp (file)
Appendix A Indexes
A.1 Concepts
| Index Entry | | Section |
|
F | | |
| File, Lisp, wasm-encoder.asd: | | The wasm-encoder․asd file |
| File, Lisp, wasm-encoder/src/package.lisp: | | The wasm-encoder/src/package․lisp file |
| File, Lisp, wasm-encoder/src/wasm-encoder.lisp: | | The wasm-encoder/src/wasm-encoder․lisp file |
|
L | | |
| Lisp File, wasm-encoder.asd: | | The wasm-encoder․asd file |
| Lisp File, wasm-encoder/src/package.lisp: | | The wasm-encoder/src/package․lisp file |
| Lisp File, wasm-encoder/src/wasm-encoder.lisp: | | The wasm-encoder/src/wasm-encoder․lisp file |
|
M | | |
| Module, wasm-encoder/src: | | The wasm-encoder/src module |
|
W | | |
| wasm-encoder.asd: | | The wasm-encoder․asd file |
| wasm-encoder/src: | | The wasm-encoder/src module |
| wasm-encoder/src/package.lisp: | | The wasm-encoder/src/package․lisp file |
| wasm-encoder/src/wasm-encoder.lisp: | | The wasm-encoder/src/wasm-encoder․lisp file |
|
A.2 Functions
| Index Entry | | Section |
|
( | | |
| (setf wasm-data-bytes) : | | Exported functions |
| (setf wasm-data-memory) : | | Exported functions |
| (setf wasm-data-mode) : | | Exported functions |
| (setf wasm-data-offset) : | | Exported functions |
| (setf wasm-element-index) : | | Exported functions |
| (setf wasm-element-init) : | | Exported functions |
| (setf wasm-element-init-expressions-expressions) : | | Exported functions |
| (setf wasm-element-init-expressions-type) : | | Internal functions |
| (setf wasm-element-init-index-functions) : | | Exported functions |
| (setf wasm-element-mode) : | | Exported functions |
| (setf wasm-element-offset) : | | Exported functions |
| (setf wasm-export-index) : | | Exported functions |
| (setf wasm-export-name) : | | Exported functions |
| (setf wasm-export-type) : | | Exported functions |
| (setf wasm-function-code) : | | Exported functions |
| (setf wasm-function-locals) : | | Exported functions |
| (setf wasm-function-type) : | | Exported functions |
| (setf wasm-function-type-params) : | | Exported functions |
| (setf wasm-function-type-results) : | | Exported functions |
| (setf wasm-global-init) : | | Exported functions |
| (setf wasm-global-mutable-p) : | | Exported functions |
| (setf wasm-global-type) : | | Exported functions |
| (setf wasm-import-desc) : | | Exported functions |
| (setf wasm-import-module) : | | Exported functions |
| (setf wasm-import-name) : | | Exported functions |
| (setf wasm-import-type) : | | Exported functions |
| (setf wasm-limit-max) : | | Exported functions |
| (setf wasm-limit-min) : | | Exported functions |
| (setf wasm-module-data) : | | Exported functions |
| (setf wasm-module-data-count) : | | Exported functions |
| (setf wasm-module-elements) : | | Exported functions |
| (setf wasm-module-exports) : | | Exported functions |
| (setf wasm-module-functions) : | | Exported functions |
| (setf wasm-module-globals) : | | Exported functions |
| (setf wasm-module-imports) : | | Exported functions |
| (setf wasm-module-memory) : | | Exported functions |
| (setf wasm-module-start) : | | Exported functions |
| (setf wasm-module-tables) : | | Internal functions |
| (setf wasm-module-types) : | | Exported functions |
| (setf wasm-table-max) : | | Exported functions |
| (setf wasm-table-min) : | | Exported functions |
| (setf wasm-table-type) : | | Exported functions |
|
C | | |
| Compiler Macro, serialize-instruction-operands : | | Internal compiler macros |
| copy-wasm-data : | | Internal functions |
| copy-wasm-element : | | Internal functions |
| copy-wasm-element-init-expressions : | | Internal functions |
| copy-wasm-element-init-index : | | Internal functions |
| copy-wasm-export : | | Internal functions |
| copy-wasm-function : | | Internal functions |
| copy-wasm-function-type : | | Internal functions |
| copy-wasm-global : | | Internal functions |
| copy-wasm-import : | | Internal functions |
| copy-wasm-limit : | | Internal functions |
| copy-wasm-module : | | Internal functions |
| copy-wasm-table : | | Internal functions |
|
D | | |
| data-segment-type-code : | | Internal functions |
|
F | | |
| Function, (setf wasm-data-bytes) : | | Exported functions |
| Function, (setf wasm-data-memory) : | | Exported functions |
| Function, (setf wasm-data-mode) : | | Exported functions |
| Function, (setf wasm-data-offset) : | | Exported functions |
| Function, (setf wasm-element-index) : | | Exported functions |
| Function, (setf wasm-element-init) : | | Exported functions |
| Function, (setf wasm-element-init-expressions-expressions) : | | Exported functions |
| Function, (setf wasm-element-init-expressions-type) : | | Internal functions |
| Function, (setf wasm-element-init-index-functions) : | | Exported functions |
| Function, (setf wasm-element-mode) : | | Exported functions |
| Function, (setf wasm-element-offset) : | | Exported functions |
| Function, (setf wasm-export-index) : | | Exported functions |
| Function, (setf wasm-export-name) : | | Exported functions |
| Function, (setf wasm-export-type) : | | Exported functions |
| Function, (setf wasm-function-code) : | | Exported functions |
| Function, (setf wasm-function-locals) : | | Exported functions |
| Function, (setf wasm-function-type) : | | Exported functions |
| Function, (setf wasm-function-type-params) : | | Exported functions |
| Function, (setf wasm-function-type-results) : | | Exported functions |
| Function, (setf wasm-global-init) : | | Exported functions |
| Function, (setf wasm-global-mutable-p) : | | Exported functions |
| Function, (setf wasm-global-type) : | | Exported functions |
| Function, (setf wasm-import-desc) : | | Exported functions |
| Function, (setf wasm-import-module) : | | Exported functions |
| Function, (setf wasm-import-name) : | | Exported functions |
| Function, (setf wasm-import-type) : | | Exported functions |
| Function, (setf wasm-limit-max) : | | Exported functions |
| Function, (setf wasm-limit-min) : | | Exported functions |
| Function, (setf wasm-module-data) : | | Exported functions |
| Function, (setf wasm-module-data-count) : | | Exported functions |
| Function, (setf wasm-module-elements) : | | Exported functions |
| Function, (setf wasm-module-exports) : | | Exported functions |
| Function, (setf wasm-module-functions) : | | Exported functions |
| Function, (setf wasm-module-globals) : | | Exported functions |
| Function, (setf wasm-module-imports) : | | Exported functions |
| Function, (setf wasm-module-memory) : | | Exported functions |
| Function, (setf wasm-module-start) : | | Exported functions |
| Function, (setf wasm-module-tables) : | | Internal functions |
| Function, (setf wasm-module-types) : | | Exported functions |
| Function, (setf wasm-table-max) : | | Exported functions |
| Function, (setf wasm-table-min) : | | Exported functions |
| Function, (setf wasm-table-type) : | | Exported functions |
| Function, copy-wasm-data : | | Internal functions |
| Function, copy-wasm-element : | | Internal functions |
| Function, copy-wasm-element-init-expressions : | | Internal functions |
| Function, copy-wasm-element-init-index : | | Internal functions |
| Function, copy-wasm-export : | | Internal functions |
| Function, copy-wasm-function : | | Internal functions |
| Function, copy-wasm-function-type : | | Internal functions |
| Function, copy-wasm-global : | | Internal functions |
| Function, copy-wasm-import : | | Internal functions |
| Function, copy-wasm-limit : | | Internal functions |
| Function, copy-wasm-module : | | Internal functions |
| Function, copy-wasm-table : | | Internal functions |
| Function, data-segment-type-code : | | Internal functions |
| Function, intern-symbol : | | Internal functions |
| Function, intern-symbols : | | Internal functions |
| Function, make-wasm-data : | | Exported functions |
| Function, make-wasm-element : | | Exported functions |
| Function, make-wasm-element-init-expressions : | | Exported functions |
| Function, make-wasm-element-init-index : | | Exported functions |
| Function, make-wasm-export : | | Exported functions |
| Function, make-wasm-function : | | Exported functions |
| Function, make-wasm-function-type : | | Exported functions |
| Function, make-wasm-global : | | Exported functions |
| Function, make-wasm-import : | | Exported functions |
| Function, make-wasm-limit : | | Exported functions |
| Function, make-wasm-module : | | Exported functions |
| Function, make-wasm-table : | | Exported functions |
| Function, serialize-32-bit : | | Internal functions |
| Function, serialize-64-bit : | | Internal functions |
| Function, serialize-block : | | Internal functions |
| Function, serialize-branch : | | Internal functions |
| Function, serialize-data : | | Internal functions |
| Function, serialize-data-count-section : | | Internal functions |
| Function, serialize-data-section : | | Internal functions |
| Function, serialize-double-float : | | Internal functions |
| Function, serialize-export : | | Internal functions |
| Function, serialize-export-section : | | Internal functions |
| Function, serialize-expression : | | Internal functions |
| Function, serialize-float : | | Internal functions |
| Function, serialize-ftype : | | Internal functions |
| Function, serialize-function : | | Internal functions |
| Function, serialize-function-types : | | Internal functions |
| Function, serialize-functions : | | Internal functions |
| Function, serialize-global : | | Internal functions |
| Function, serialize-global-section : | | Internal functions |
| Function, serialize-i32 : | | Internal functions |
| Function, serialize-import : | | Internal functions |
| Function, serialize-imports : | | Internal functions |
| Function, serialize-instruction : | | Internal functions |
| Function, serialize-instructions : | | Internal functions |
| Function, serialize-limit : | | Internal functions |
| Function, serialize-memory : | | Internal functions |
| Function, serialize-memory-instruction : | | Internal functions |
| Function, serialize-memory-types : | | Internal functions |
| Function, serialize-module : | | Exported functions |
| Function, serialize-nil-type : | | Internal functions |
| Function, serialize-ref-type : | | Internal functions |
| Function, serialize-section : | | Internal functions |
| Function, serialize-signed : | | Internal functions |
| Function, serialize-start-section : | | Internal functions |
| Function, serialize-string : | | Internal functions |
| Function, serialize-table : | | Internal functions |
| Function, serialize-table-element : | | Internal functions |
| Function, serialize-table-element-init : | | Internal functions |
| Function, serialize-table-elements : | | Internal functions |
| Function, serialize-table-types : | | Internal functions |
| Function, serialize-type : | | Internal functions |
| Function, serialize-types : | | Internal functions |
| Function, serialize-u32 : | | Internal functions |
| Function, serialize-unsigned : | | Internal functions |
| Function, serialize-vector : | | Internal functions |
| Function, serialize-with-byte-size : | | Internal functions |
| Function, table-element-type-code : | | Internal functions |
| Function, wasm-data-bytes : | | Exported functions |
| Function, wasm-data-memory : | | Exported functions |
| Function, wasm-data-mode : | | Exported functions |
| Function, wasm-data-offset : | | Exported functions |
| Function, wasm-data-p : | | Exported functions |
| Function, wasm-element-index : | | Exported functions |
| Function, wasm-element-init : | | Exported functions |
| Function, wasm-element-init-expressions-expressions : | | Exported functions |
| Function, wasm-element-init-expressions-p : | | Exported functions |
| Function, wasm-element-init-expressions-type : | | Internal functions |
| Function, wasm-element-init-index-functions : | | Exported functions |
| Function, wasm-element-init-index-p : | | Exported functions |
| Function, wasm-element-mode : | | Exported functions |
| Function, wasm-element-offset : | | Exported functions |
| Function, wasm-element-p : | | Exported functions |
| Function, wasm-export-index : | | Exported functions |
| Function, wasm-export-name : | | Exported functions |
| Function, wasm-export-p : | | Exported functions |
| Function, wasm-export-type : | | Exported functions |
| Function, wasm-function-code : | | Exported functions |
| Function, wasm-function-locals : | | Exported functions |
| Function, wasm-function-p : | | Exported functions |
| Function, wasm-function-type : | | Exported functions |
| Function, wasm-function-type-p : | | Exported functions |
| Function, wasm-function-type-params : | | Exported functions |
| Function, wasm-function-type-results : | | Exported functions |
| Function, wasm-global-init : | | Exported functions |
| Function, wasm-global-mutable-p : | | Exported functions |
| Function, wasm-global-p : | | Exported functions |
| Function, wasm-global-type : | | Exported functions |
| Function, wasm-import-desc : | | Exported functions |
| Function, wasm-import-module : | | Exported functions |
| Function, wasm-import-name : | | Exported functions |
| Function, wasm-import-p : | | Exported functions |
| Function, wasm-import-type : | | Exported functions |
| Function, wasm-limit-max : | | Exported functions |
| Function, wasm-limit-min : | | Exported functions |
| Function, wasm-limit-p : | | Exported functions |
| Function, wasm-module-data : | | Exported functions |
| Function, wasm-module-data-count : | | Exported functions |
| Function, wasm-module-elements : | | Exported functions |
| Function, wasm-module-exports : | | Exported functions |
| Function, wasm-module-functions : | | Exported functions |
| Function, wasm-module-globals : | | Exported functions |
| Function, wasm-module-imports : | | Exported functions |
| Function, wasm-module-memory : | | Exported functions |
| Function, wasm-module-p : | | Exported functions |
| Function, wasm-module-start : | | Exported functions |
| Function, wasm-module-tables : | | Internal functions |
| Function, wasm-module-types : | | Exported functions |
| Function, wasm-table-max : | | Exported functions |
| Function, wasm-table-min : | | Exported functions |
| Function, wasm-table-p : | | Exported functions |
| Function, wasm-table-type : | | Exported functions |
|
G | | |
| Generic Function, serialize-instruction-operands : | | Internal generic functions |
| Generic Function, serialize-table-instruction : | | Internal generic functions |
| Generic Function, serialize-variable-instruction : | | Internal generic functions |
|
I | | |
| intern-symbol : | | Internal functions |
| intern-symbols : | | Internal functions |
|
M | | |
| make-wasm-data : | | Exported functions |
| make-wasm-element : | | Exported functions |
| make-wasm-element-init-expressions : | | Exported functions |
| make-wasm-element-init-index : | | Exported functions |
| make-wasm-export : | | Exported functions |
| make-wasm-function : | | Exported functions |
| make-wasm-function-type : | | Exported functions |
| make-wasm-global : | | Exported functions |
| make-wasm-import : | | Exported functions |
| make-wasm-limit : | | Exported functions |
| make-wasm-module : | | Exported functions |
| make-wasm-table : | | Exported functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-instruction-operands : | | Internal generic functions |
| Method, serialize-table-instruction : | | Internal generic functions |
| Method, serialize-variable-instruction : | | Internal generic functions |
|
S | | |
| serialize-32-bit : | | Internal functions |
| serialize-64-bit : | | Internal functions |
| serialize-block : | | Internal functions |
| serialize-branch : | | Internal functions |
| serialize-data : | | Internal functions |
| serialize-data-count-section : | | Internal functions |
| serialize-data-section : | | Internal functions |
| serialize-double-float : | | Internal functions |
| serialize-export : | | Internal functions |
| serialize-export-section : | | Internal functions |
| serialize-expression : | | Internal functions |
| serialize-float : | | Internal functions |
| serialize-ftype : | | Internal functions |
| serialize-function : | | Internal functions |
| serialize-function-types : | | Internal functions |
| serialize-functions : | | Internal functions |
| serialize-global : | | Internal functions |
| serialize-global-section : | | Internal functions |
| serialize-i32 : | | Internal functions |
| serialize-import : | | Internal functions |
| serialize-imports : | | Internal functions |
| serialize-instruction : | | Internal functions |
| serialize-instruction-operands : | | Internal compiler macros |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instruction-operands : | | Internal generic functions |
| serialize-instructions : | | Internal functions |
| serialize-limit : | | Internal functions |
| serialize-memory : | | Internal functions |
| serialize-memory-instruction : | | Internal functions |
| serialize-memory-types : | | Internal functions |
| serialize-module : | | Exported functions |
| serialize-nil-type : | | Internal functions |
| serialize-ref-type : | | Internal functions |
| serialize-section : | | Internal functions |
| serialize-signed : | | Internal functions |
| serialize-start-section : | | Internal functions |
| serialize-string : | | Internal functions |
| serialize-table : | | Internal functions |
| serialize-table-element : | | Internal functions |
| serialize-table-element-init : | | Internal functions |
| serialize-table-elements : | | Internal functions |
| serialize-table-instruction : | | Internal generic functions |
| serialize-table-instruction : | | Internal generic functions |
| serialize-table-types : | | Internal functions |
| serialize-type : | | Internal functions |
| serialize-types : | | Internal functions |
| serialize-u32 : | | Internal functions |
| serialize-unsigned : | | Internal functions |
| serialize-variable-instruction : | | Internal generic functions |
| serialize-variable-instruction : | | Internal generic functions |
| serialize-vector : | | Internal functions |
| serialize-with-byte-size : | | Internal functions |
|
T | | |
| table-element-type-code : | | Internal functions |
|
W | | |
| wasm-data-bytes : | | Exported functions |
| wasm-data-memory : | | Exported functions |
| wasm-data-mode : | | Exported functions |
| wasm-data-offset : | | Exported functions |
| wasm-data-p : | | Exported functions |
| wasm-element-index : | | Exported functions |
| wasm-element-init : | | Exported functions |
| wasm-element-init-expressions-expressions : | | Exported functions |
| wasm-element-init-expressions-p : | | Exported functions |
| wasm-element-init-expressions-type : | | Internal functions |
| wasm-element-init-index-functions : | | Exported functions |
| wasm-element-init-index-p : | | Exported functions |
| wasm-element-mode : | | Exported functions |
| wasm-element-offset : | | Exported functions |
| wasm-element-p : | | Exported functions |
| wasm-export-index : | | Exported functions |
| wasm-export-name : | | Exported functions |
| wasm-export-p : | | Exported functions |
| wasm-export-type : | | Exported functions |
| wasm-function-code : | | Exported functions |
| wasm-function-locals : | | Exported functions |
| wasm-function-p : | | Exported functions |
| wasm-function-type : | | Exported functions |
| wasm-function-type-p : | | Exported functions |
| wasm-function-type-params : | | Exported functions |
| wasm-function-type-results : | | Exported functions |
| wasm-global-init : | | Exported functions |
| wasm-global-mutable-p : | | Exported functions |
| wasm-global-p : | | Exported functions |
| wasm-global-type : | | Exported functions |
| wasm-import-desc : | | Exported functions |
| wasm-import-module : | | Exported functions |
| wasm-import-name : | | Exported functions |
| wasm-import-p : | | Exported functions |
| wasm-import-type : | | Exported functions |
| wasm-limit-max : | | Exported functions |
| wasm-limit-min : | | Exported functions |
| wasm-limit-p : | | Exported functions |
| wasm-module-data : | | Exported functions |
| wasm-module-data-count : | | Exported functions |
| wasm-module-elements : | | Exported functions |
| wasm-module-exports : | | Exported functions |
| wasm-module-functions : | | Exported functions |
| wasm-module-globals : | | Exported functions |
| wasm-module-imports : | | Exported functions |
| wasm-module-memory : | | Exported functions |
| wasm-module-p : | | Exported functions |
| wasm-module-start : | | Exported functions |
| wasm-module-tables : | | Internal functions |
| wasm-module-types : | | Exported functions |
| wasm-table-max : | | Exported functions |
| wasm-table-min : | | Exported functions |
| wasm-table-p : | | Exported functions |
| wasm-table-type : | | Exported functions |
|
A.3 Variables
| Index Entry | | Section |
|
+ | | |
| +code-section-id+ : | | Internal constants |
| +custom-section-id+ : | | Internal constants |
| +data-count-section-id+ : | | Internal constants |
| +data-section-id+ : | | Internal constants |
| +element-section-id+ : | | Internal constants |
| +export-section-id+ : | | Internal constants |
| +function-section-id+ : | | Internal constants |
| +global-section-id+ : | | Internal constants |
| +import-section-id+ : | | Internal constants |
| +memory-section-id+ : | | Internal constants |
| +op-codes+ : | | Internal constants |
| +start-section-id+ : | | Internal constants |
| +table-section-id+ : | | Internal constants |
| +type-section-id+ : | | Internal constants |
|
B | | |
| bytes : | | Exported structures |
|
C | | |
| code : | | Exported structures |
| Constant, +code-section-id+ : | | Internal constants |
| Constant, +custom-section-id+ : | | Internal constants |
| Constant, +data-count-section-id+ : | | Internal constants |
| Constant, +data-section-id+ : | | Internal constants |
| Constant, +element-section-id+ : | | Internal constants |
| Constant, +export-section-id+ : | | Internal constants |
| Constant, +function-section-id+ : | | Internal constants |
| Constant, +global-section-id+ : | | Internal constants |
| Constant, +import-section-id+ : | | Internal constants |
| Constant, +memory-section-id+ : | | Internal constants |
| Constant, +op-codes+ : | | Internal constants |
| Constant, +start-section-id+ : | | Internal constants |
| Constant, +table-section-id+ : | | Internal constants |
| Constant, +type-section-id+ : | | Internal constants |
|
D | | |
| data : | | Exported structures |
| data-count : | | Exported structures |
| desc : | | Exported structures |
|
E | | |
| elements : | | Exported structures |
| exports : | | Exported structures |
| expressions : | | Exported structures |
|
F | | |
| functions : | | Exported structures |
| functions : | | Exported structures |
|
G | | |
| globals : | | Exported structures |
|
I | | |
| imports : | | Exported structures |
| index : | | Exported structures |
| index : | | Exported structures |
| init : | | Exported structures |
| init : | | Exported structures |
|
L | | |
| locals : | | Exported structures |
|
M | | |
| max : | | Exported structures |
| memory : | | Exported structures |
| memory : | | Exported structures |
| min : | | Exported structures |
| mode : | | Exported structures |
| mode : | | Exported structures |
| module : | | Exported structures |
| mutable-p : | | Exported structures |
|
N | | |
| name : | | Exported structures |
| name : | | Exported structures |
|
O | | |
| offset : | | Exported structures |
| offset : | | Exported structures |
|
P | | |
| params : | | Exported structures |
|
R | | |
| results : | | Exported structures |
|
S | | |
| Slot, bytes : | | Exported structures |
| Slot, code : | | Exported structures |
| Slot, data : | | Exported structures |
| Slot, data-count : | | Exported structures |
| Slot, desc : | | Exported structures |
| Slot, elements : | | Exported structures |
| Slot, exports : | | Exported structures |
| Slot, expressions : | | Exported structures |
| Slot, functions : | | Exported structures |
| Slot, functions : | | Exported structures |
| Slot, globals : | | Exported structures |
| Slot, imports : | | Exported structures |
| Slot, index : | | Exported structures |
| Slot, index : | | Exported structures |
| Slot, init : | | Exported structures |
| Slot, init : | | Exported structures |
| Slot, locals : | | Exported structures |
| Slot, max : | | Exported structures |
| Slot, memory : | | Exported structures |
| Slot, memory : | | Exported structures |
| Slot, min : | | Exported structures |
| Slot, mode : | | Exported structures |
| Slot, mode : | | Exported structures |
| Slot, module : | | Exported structures |
| Slot, mutable-p : | | Exported structures |
| Slot, name : | | Exported structures |
| Slot, name : | | Exported structures |
| Slot, offset : | | Exported structures |
| Slot, offset : | | Exported structures |
| Slot, params : | | Exported structures |
| Slot, results : | | Exported structures |
| Slot, start : | | Exported structures |
| Slot, tables : | | Exported structures |
| Slot, type : | | Exported structures |
| Slot, type : | | Exported structures |
| Slot, type : | | Exported structures |
| Slot, type : | | Exported structures |
| Slot, type : | | Exported structures |
| Slot, type : | | Exported structures |
| Slot, types : | | Exported structures |
| start : | | Exported structures |
|
T | | |
| tables : | | Exported structures |
| type : | | Exported structures |
| type : | | Exported structures |
| type : | | Exported structures |
| type : | | Exported structures |
| type : | | Exported structures |
| type : | | Exported structures |
| types : | | Exported structures |
|
A.4 Data types
| Index Entry | | Section |
|
I | | |
| i32 : | | Internal types |
| i64 : | | Internal types |
|
P | | |
| Package, wasm-encoder : | | The wasm-encoder package |
|
S | | |
| Structure, wasm-data : | | Exported structures |
| Structure, wasm-element : | | Exported structures |
| Structure, wasm-element-init-expressions : | | Exported structures |
| Structure, wasm-element-init-index : | | Exported structures |
| Structure, wasm-export : | | Exported structures |
| Structure, wasm-function : | | Exported structures |
| Structure, wasm-function-type : | | Exported structures |
| Structure, wasm-global : | | Exported structures |
| Structure, wasm-import : | | Exported structures |
| Structure, wasm-limit : | | Exported structures |
| Structure, wasm-module : | | Exported structures |
| Structure, wasm-table : | | Exported structures |
| System, wasm-encoder : | | The wasm-encoder system |
|
T | | |
| Type, i32 : | | Internal types |
| Type, i64 : | | Internal types |
| Type, u32 : | | Internal types |
| Type, u64 : | | Internal types |
|
U | | |
| u32 : | | Internal types |
| u64 : | | Internal types |
|
W | | |
| wasm-data : | | Exported structures |
| wasm-element : | | Exported structures |
| wasm-element-init-expressions : | | Exported structures |
| wasm-element-init-index : | | Exported structures |
| wasm-encoder : | | The wasm-encoder system |
| wasm-encoder : | | The wasm-encoder package |
| wasm-export : | | Exported structures |
| wasm-function : | | Exported structures |
| wasm-function-type : | | Exported structures |
| wasm-global : | | Exported structures |
| wasm-import : | | Exported structures |
| wasm-limit : | | Exported structures |
| wasm-module : | | Exported structures |
| wasm-table : | | Exported structures |
|