The wasm-encoder Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

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 Wed Oct 13 13:03:12 2021 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

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.



Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

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
Source

wasm-encoder.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 wasm-encoder/src

Parent

wasm-encoder (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 wasm-encoder.asd

Location

wasm-encoder.asd

Systems

wasm-encoder (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 wasm-encoder/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

wasm-encoder


Previous: , Up: Lisp files   [Contents][Index]

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

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

5.1 wasm-encoder

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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)


Previous: , Up: Exported definitions   [Contents][Index]

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)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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-20210807-git/src/sbcl.lisp


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Previous: , Up: Internal definitions   [Contents][Index]

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)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M   W  
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

Jump to:   F   L   M   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
C   D   F   G   I   M   S   T   W  
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

Jump to:   (  
C   D   F   G   I   M   S   T   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   +  
B   C   D   E   F   G   I   L   M   N   O   P   R   S   T  
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

Jump to:   +  
B   C   D   E   F   G   I   L   M   N   O   P   R   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   I   P   S   T   U   W  
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

Jump to:   I   P   S   T   U   W