Modules

WebAssembly programs are organized into modules, which are the unit of deployment, loading, and compilation. A module collects definitions for types, functions, tables, memories, and globals. In addition, it can declare imports and exports and provide initialization in the form of data and element segments, or a start function.

$$\begin{array}{r}\begin{array}{lllll}& \mathit{module}& ::=& \{& \mathsf{types}\mathit{vec}(\mathit{functype}),\\ & & & & \mathsf{funcs}\mathit{vec}(\mathit{func}),\\ & & & & \mathsf{tables}\mathit{vec}(\mathit{table}),\\ & & & & \mathsf{mems}\mathit{vec}(\mathit{mem}),\\ & & & & \mathsf{globals}\mathit{vec}(\mathit{global}),\\ & & & & \mathsf{elems}\mathit{vec}(\mathit{elem}),\\ & & & & \mathsf{datas}\mathit{vec}(\mathit{data}),\\ & & & & \mathsf{start}{\mathit{start}}^{?},\\ & & & & \mathsf{imports}\mathit{vec}(\mathit{import}),\\ & & & & \mathsf{exports}\mathit{vec}(\mathit{export})\}\end{array}\end{array}$$

Each of the vectors – and thus the entire module – may be empty.

Indices

Definitions are referenced with zero-based indices. Each class of definition has its own index space, as distinguished by the following classes.

$$\begin{array}{r}\begin{array}{llll}& \mathit{typeidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{funcidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{tableidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{memidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{globalidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{elemidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{dataidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{localidx}& ::=& \mathit{u}\mathit{32}\\ & \mathit{labelidx}& ::=& \mathit{u}\mathit{32}\end{array}\end{array}$$

The index space for functions, tables, memories and globals includes respective imports declared in the same module. The indices of these imports precede the indices of other definitions in the same index space.

Element indices reference element segments and data indices reference data segments.

The index space for locals is only accessible inside a function and includes the parameters of that function, which precede the local variables.

Label indices reference structured control instructions inside an instruction sequence.

Conventions

• The meta variable $l$ ranges over label indices.

• The meta variables $x,y$ range over indices in any of the other index spaces.

• The notation $\mathrm{idx}(A)$ denotes the set of indices from index space $\mathit{idx}$ occurring free in $A$. Sometimes this set is reinterpreted as the vector of its elements.

Note

For example, if ${\mathit{instr}}^{\ast }$ is $(\mathsf{data}\mathsf{.}\mathsf{drop}x)(\mathsf{memory}\mathsf{.}\mathsf{init}y)$, then $\mathrm{dataidx}({\mathit{instr}}^{\ast })=\{x,y\}$, or equivalently, the vector $xy$.

Types

The $\mathsf{types}$ component of a module defines a vector of function types.

All function types used in a module must be defined in this component. They are referenced by type indices.

Note

Future versions of WebAssembly may add additional forms of type definitions.

Functions

The $\mathsf{funcs}$ component of a module defines a vector of functions with the following structure:

$$\begin{array}{r}\begin{array}{llll}& \mathit{func}& ::=& \{\mathsf{type}\mathit{typeidx},\mathsf{locals}\mathit{vec}(\mathit{valtype}),\mathsf{body}\mathit{expr}\}\end{array}\end{array}$$

The $\mathsf{type}$ of a function declares its signature by reference to a type defined in the module. The parameters of the function are referenced through 0-based local indices in the function’s body; they are mutable.

The $\mathsf{locals}$ declare a vector of mutable local variables and their types. These variables are referenced through local indices in the function’s body. The index of the first local is the smallest index not referencing a parameter.

The $\mathsf{body}$ is an instruction sequence that upon termination must produce a stack matching the function type’s result type.

Functions are referenced through function indices, starting with the smallest index not referencing a function import.

Tables

The $\mathsf{tables}$ component of a module defines a vector of tables described by their table type:

$$\begin{array}{r}\begin{array}{llll}& \mathit{table}& ::=& \{\mathsf{type}\mathit{tabletype}\}\end{array}\end{array}$$

A table is a vector of opaque values of a particular reference type. The $\mathsf{min}$ size in the limits of the table type specifies the initial size of that table, while its $\mathsf{max}$, if present, restricts the size to which it can grow later.

Tables can be initialized through element segments.

Tables are referenced through table indices, starting with the smallest index not referencing a table import. Most constructs implicitly reference table index $0$.

Memories

The $\mathsf{mems}$ component of a module defines a vector of linear memories (or memories for short) as described by their memory type:

$$\begin{array}{r}\begin{array}{llll}& \mathit{mem}& ::=& \{\mathsf{type}\mathit{memtype}\}\end{array}\end{array}$$

A memory is a vector of raw uninterpreted bytes. The $\mathsf{min}$ size in the limits of the memory type specifies the initial size of that memory, while its $\mathsf{max}$, if present, restricts the size to which it can grow later. Both are in units of page size.

Memories can be initialized through data segments.

Memories are referenced through memory indices, starting with the smallest index not referencing a memory import. Most constructs implicitly reference memory index $0$.

Note

In the current version of WebAssembly, at most one memory may be defined or imported in a single module, and all constructs implicitly reference this memory $0$. This restriction may be lifted in future versions.

Globals

The $\mathsf{globals}$ component of a module defines a vector of global variables (or globals for short):

$$\begin{array}{r}\begin{array}{llll}& \mathit{global}& ::=& \{\mathsf{type}\mathit{globaltype},\mathsf{init}\mathit{expr}\}\end{array}\end{array}$$

Each global stores a single value of the given global type. Its $\mathsf{type}$ also specifies whether a global is immutable or mutable. Moreover, each global is initialized with an $\mathsf{init}$ value given by a constant initializer expression.

Globals are referenced through global indices, starting with the smallest index not referencing a global import.

Element Segments

The initial contents of a table is uninitialized. Element segments can be used to initialize a subrange of a table from a static vector of elements.

The $\mathsf{elems}$ component of a module defines a vector of element segments. Each element segment defines a reference type and a corresponding list of constant element expressions.

Element segments have a mode that identifies them as either passive, active, or declarative. A passive element segment’s elements can be copied to a table using the $\mathsf{table}\mathsf{.}\mathsf{init}$ instruction. An active element segment copies its elements into a table during instantiation, as specified by a table index and a constant expression defining an offset into that table. A declarative element segment is not available at runtime but merely serves to forward-declare references that are formed in code with instructions like $\mathsf{ref}\mathsf{.}\mathsf{func}$.

$$\begin{array}{r}\begin{array}{llll}& \mathit{elem}& ::=& \{\mathsf{type}\mathit{reftype},\mathsf{init}\mathit{vec}(\mathit{expr}),\mathsf{mode}\mathit{elemmode}\}\\ & \mathit{elemmode}& ::=& \mathsf{passive}\\ & & |& \mathsf{active}\{\mathsf{table}\mathit{tableidx},\mathsf{offset}\mathit{expr}\}\\ & & |& \mathsf{declarative}\end{array}\end{array}$$

The $\mathsf{offset}$ is given by a constant expression.

Element segments are referenced through element indices.

Data Segments

The initial contents of a memory are zero bytes. Data segments can be used to initialize a range of memory from a static vector of bytes.

The $\mathsf{datas}$ component of a module defines a vector of data segments.

Like element segments, data segments have a mode that identifies them as either passive or active. A passive data segment’s contents can be copied into a memory using the $\mathsf{memory}\mathsf{.}\mathsf{init}$ instruction. An active data segment copies its contents into a memory during instantiation, as specified by a memory index and a constant expression defining an offset into that memory.

$$\begin{array}{r}\begin{array}{llll}& \mathit{data}& ::=& \{\mathsf{init}\mathit{vec}(\mathit{byte}),\mathsf{mode}\mathit{datamode}\}\\ & \mathit{datamode}& ::=& \mathsf{passive}\\ & & |& \mathsf{active}\{\mathsf{memory}\mathit{memidx},\mathsf{offset}\mathit{expr}\}\end{array}\end{array}$$

Data segments are referenced through data indices.

Note

In the current version of WebAssembly, at most one memory is allowed in a module. Consequently, the only valid $\mathit{memidx}$ is $0$.

Start Function

The $\mathsf{start}$ component of a module declares the function index of a start function that is automatically invoked when the module is instantiated, after tables and memories have been initialized.

$$\begin{array}{r}\begin{array}{llll}& \mathit{start}& ::=& \{\mathsf{func}\mathit{funcidx}\}\end{array}\end{array}$$

Note

The start function is intended for initializing the state of a module. The module and its exports are not accessible externally before this initialization has completed.

Exports

The $\mathsf{exports}$ component of a module defines a set of exports that become accessible to the host environment once the module has been instantiated.

$$\begin{array}{r}\begin{array}{llcl}& \mathit{export}& ::=& \{\mathsf{name}\mathit{name},\mathsf{desc}\mathit{exportdesc}\}\\ & \mathit{exportdesc}& ::=& \mathsf{func}\mathit{funcidx}\\ & & |& \mathsf{table}\mathit{tableidx}\\ & & |& \mathsf{mem}\mathit{memidx}\\ & & |& \mathsf{global}\mathit{globalidx}\end{array}\end{array}$$

Each export is labeled by a unique name. Exportable definitions are functions, tables, memories, and globals, which are referenced through a respective descriptor.

Conventions

The following auxiliary notation is defined for sequences of exports, filtering out indices of a specific kind in an order-preserving fashion:

• $\mathrm{funcs}({\mathit{export}}^{\ast })=[\mathit{funcidx}|\mathsf{func}\mathit{funcidx}\in (\mathit{export}.\mathsf{desc}{)}^{\ast }]$

• $\mathrm{tables}({\mathit{export}}^{\ast })=[\mathit{tableidx}|\mathsf{table}\mathit{tableidx}\in (\mathit{export}.\mathsf{desc}{)}^{\ast }]$

• $\mathrm{mems}({\mathit{export}}^{\ast })=[\mathit{memidx}|\mathsf{mem}\mathit{memidx}\in (\mathit{export}.\mathsf{desc}{)}^{\ast }]$

• $\mathrm{globals}({\mathit{export}}^{\ast })=[\mathit{globalidx}|\mathsf{global}\mathit{globalidx}\in (\mathit{export}.\mathsf{desc}{)}^{\ast }]$

Imports

The $\mathsf{imports}$ component of a module defines a set of imports that are required for instantiation.

$$\begin{array}{r}\begin{array}{llll}& \mathit{import}& ::=& \{\mathsf{module}\mathit{name},\mathsf{name}\mathit{name},\mathsf{desc}\mathit{importdesc}\}\\ & \mathit{importdesc}& ::=& \mathsf{func}\mathit{typeidx}\\ & & |& \mathsf{table}\mathit{tabletype}\\ & & |& \mathsf{mem}\mathit{memtype}\\ & & |& \mathsf{global}\mathit{globaltype}\end{array}\end{array}$$

Each import is labeled by a two-level name space, consisting of a $\mathsf{module}$ name and a $\mathsf{name}$ for an entity within that module. Importable definitions are functions, tables, memories, and globals. Each import is specified by a descriptor with a respective type that a definition provided during instantiation is required to match.

Every import defines an index in the respective index space. In each index space, the indices of imports go before the first index of any definition contained in the module itself.

Note

Unlike export names, import names are not necessarily unique. It is possible to import the same $\mathsf{module}$/$\mathsf{name}$ pair multiple times; such imports may even have different type descriptions, including different kinds of entities. A module with such imports can still be instantiated depending on the specifics of how an embedder allows resolving and supplying imports. However, embedders are not required to support such overloading, and a WebAssembly module itself cannot implement an overloaded name.