Types

Various entities in WebAssembly are classified by types. Types are checked during validation, instantiation, and possibly execution.

Number Types

Number types classify numeric values.

$$\begin{array}{r}\begin{array}{llll}& \mathit{numtype}& ::=& \mathsf{i}\mathsf{32}|\mathsf{i}\mathsf{64}|\mathsf{f}\mathsf{32}|\mathsf{f}\mathsf{64}\end{array}\end{array}$$

The types $\mathsf{i}\mathsf{32}$ and $\mathsf{i}\mathsf{64}$ classify 32 and 64 bit integers, respectively. Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.

The types $\mathsf{f}\mathsf{32}$ and $\mathsf{f}\mathsf{64}$ classify 32 and 64 bit floating-point data, respectively. They correspond to the respective binary floating-point representations, also known as single and double precision, as defined by the IEEE 754 standard (Section 3.3).

Number types are transparent, meaning that their bit patterns can be observed. Values of number type can be stored in memories.

Conventions

• The notation $|t|$ denotes the bit width of a number type $t$. That is, $|\mathsf{i}\mathsf{32}|=|\mathsf{f}\mathsf{32}|=32$ and $|\mathsf{i}\mathsf{64}|=|\mathsf{f}\mathsf{64}|=64$.

Vector Types

Vector types classify vectors of numeric values processed by vector instructions (also known as SIMD instructions, single instruction multiple data).

$$\begin{array}{r}\begin{array}{llll}& \mathit{vectype}& ::=& \mathsf{v}\mathsf{128}\end{array}\end{array}$$

The type $\mathsf{v}\mathsf{128}$ corresponds to a 128 bit vector of packed integer or floating-point data. The packed data can be interpreted as signed or unsigned integers, single or double precision floating-point values, or a single 128 bit type. The interpretation is determined by individual operations.

Vector types, like number types are transparent, meaning that their bit patterns can be observed. Values of vector type can be stored in memories.

Conventions

• The notation $|t|$ for bit width extends to vector types as well, that is, $|\mathsf{v}\mathsf{128}|=128$.

Heap Types

Heap types classify objects in the runtime store.

$$\begin{array}{r}\begin{array}{llll}& \mathit{heaptype}& ::=& \mathsf{func}|\mathsf{extern}|\mathit{typeidx}|\mathit{functype}|\mathsf{bot}\end{array}\end{array}$$

The type $\mathsf{func}$ denotes the infinite union of all types of functions, regardless of their concrete function types.

The type $\mathsf{extern}$ denotes the infinite union of all objects owned by the embedder and that can be passed into WebAssembly under this type.

A concrete heap type consists of a type index and classifies an object of the respective type defined in some module.

A concrete heap type can also consist of a function type directly. However, this form is representable in neither the binary format nor the text format, such that it cannot be used in a program; it only occurs during validation or execution, as the result of substituting a type index with its definition.

The type $\mathsf{bot}$ is a subtype of all other heap types. By virtue of being representable in neither the binary format nor the text format, it cannot be used in a program; it only occurs during validation, as a part of a possible operand type for instructions.

A type of any form is closed when it does not contain a heap type that is a type index, i.e., all type indices have been substituted with their defined type.

Convention

• $t[x^{\ast }\mathbf{:=}{\mathit{ft}}^{\ast }]$ denotes the parallel substitution of type indices $x^{\ast }$ with function types ${\mathit{ft}}^{\ast }$, provided $|x^{\ast }|=|{\mathit{ft}}^{\ast }|$ in type $t$.

• $t[\mathbf{:=}{\mathit{ft}}^{\ast }]$ is shorthand for the substitution $t[x^{\ast }\mathbf{:=}{\mathit{ft}}^{\ast }]$ where $x^{\ast }=0\cdots (|{\mathit{ft}}^{\ast }|-1)$ in type $t$.

Reference Types

Reference types classify values that are first-class references to objects in the runtime store.

$$\begin{array}{r}\begin{array}{llll}& \mathit{reftype}& ::=& \mathsf{ref}{\mathsf{null}}^{?}\mathit{heaptype}\end{array}\end{array}$$

A reference type is characterised by the heap type it points to.

In addition, a reference type of the form $\mathsf{ref}\mathsf{null}\mathit{ht}$ is nullable, meaning that it can either be a proper reference to $\mathit{ht}$ or null. Other references are non-null.

Reference types are opaque, meaning that neither their size nor their bit pattern can be observed. Values of reference type can be stored in tables.

Conventions

• The reference type $\mathsf{funcref}$ is an abbreviation for $\mathsf{ref}\mathsf{null}\mathsf{func}$.

• The reference type $\mathsf{externref}$ is an abbreviation for $\mathsf{ref}\mathsf{null}\mathsf{extern}$.

Value Types

Value types classify the individual values that WebAssembly code can compute with and the values that a variable accepts. They are either number types, vector types, reference types, or the unique bottom type, written $\mathsf{bot}$.

The type $\mathsf{bot}$ is a subtype of all other value types. By virtue of being representable in neither the binary format nor the text format, it cannot be used in a program; it only occurs during validation, as a possible operand type for instructions.

$$\begin{array}{r}\begin{array}{llll}& \mathit{valtype}& ::=& \mathit{numtype}|\mathit{vectype}|\mathit{reftype}|\mathsf{bot}\end{array}\end{array}$$

Conventions

• The meta variable $t$ ranges over value types or subclasses thereof where clear from context.

Result Types

Result types classify the result of executing instructions or functions, which is a sequence of values, written with brackets.

$$\begin{array}{r}\begin{array}{llll}& \mathit{resulttype}& ::=& [\mathit{vec}(\mathit{valtype})]\end{array}\end{array}$$

Instruction Types

Instruction types classify the behaviour of instructions or instruction sequences, by describing how they manipulate the operand stack and the initialization status of locals:

$$\begin{array}{r}\begin{array}{llll}& \mathit{instrtype}& ::=& \mathit{resulttype}{\to }_{{\mathit{localidx}}^{\ast }}\mathit{resulttype}\end{array}\end{array}$$

An instruction type $[t_1^{\ast }]{\to }_{x^{\ast }}[t_2^{\ast }]$ describes the required input stack with argument values of types $t_1^{\ast }$ that an instruction pops off and the provided output stack with result values of types $t_2^{\ast }$ that it pushes back. Moreover, it enumerates the indices $x^{\ast }$ of locals that have been set by the instruction or sequence.

Note

Instruction types are only used for validation, they do not occur in programs.

Local Types

Local types classify locals, by describing their value type as well as their initialization status:

$$\begin{array}{r}\begin{array}{llll}& \mathit{init}& ::=& \mathsf{set}|\mathsf{unset}\\ & \mathit{localtype}& ::=& \mathit{init}\mathit{valtype}\end{array}\end{array}$$

Note

Local types are only used for validation, they do not occur in programs.

Function Types

Function types classify the signature of functions, mapping a vector of parameters to a vector of results. They are also used to classify the inputs and outputs of instructions.

$$\begin{array}{r}\begin{array}{llll}& \mathit{functype}& ::=& \mathit{resulttype}\to \mathit{resulttype}\end{array}\end{array}$$

Defined Types

Defined types are the ones that can be defined in a module, assigning them a type index.

$$\begin{array}{r}\begin{array}{llll}& \mathit{deftype}& ::=& \mathit{functype}\end{array}\end{array}$$

Note

Future versions of WebAssembly may introduce additional forms of defined types.

Limits

Limits classify the size range of resizeable storage associated with memory types and table types.

$$\begin{array}{r}\begin{array}{llll}& \mathit{limits}& ::=& \{\mathsf{min}\mathit{u}\mathit{32},\mathsf{max}{\mathit{u}\mathit{32}}^{?}\}\end{array}\end{array}$$

If no maximum is given, the respective storage can grow to any size.

Memory Types

Memory types classify linear memories and their size range.

$$\begin{array}{r}\begin{array}{llll}& \mathit{memtype}& ::=& \mathit{limits}\end{array}\end{array}$$

The limits constrain the minimum and optionally the maximum size of a memory. The limits are given in units of page size.

Table Types

Table types classify tables over elements of reference type within a size range.

$$\begin{array}{r}\begin{array}{llll}& \mathit{tabletype}& ::=& \mathit{limits}\mathit{reftype}\end{array}\end{array}$$

Like memories, tables are constrained by limits for their minimum and optionally maximum size. The limits are given in numbers of entries.

Note

In future versions of WebAssembly, additional element types may be introduced.

Global Types

Global types classify global variables, which hold a value and can either be mutable or immutable.

$$\begin{array}{r}\begin{array}{llll}& \mathit{globaltype}& ::=& \mathit{mut}\mathit{valtype}\\ & \mathit{mut}& ::=& \mathsf{const}|\mathsf{var}\end{array}\end{array}$$

External Types

External types classify imports and external values with their respective types.

$$\begin{array}{r}\begin{array}{llll}& \mathit{externtype}& ::=& \mathsf{func}\mathit{functype}|\mathsf{table}\mathit{tabletype}|\mathsf{mem}\mathit{memtype}|\mathsf{global}\mathit{globaltype}\end{array}\end{array}$$

Conventions

The following auxiliary notation is defined for sequences of external types. It filters out entries of a specific kind in an order-preserving fashion:

• $\mathrm{funcs}({\mathit{externtype}}^{\ast })=[\mathit{functype}|(\mathsf{func}\mathit{functype})\in {\mathit{externtype}}^{\ast }]$

• $\mathrm{tables}({\mathit{externtype}}^{\ast })=[\mathit{tabletype}|(\mathsf{table}\mathit{tabletype})\in {\mathit{externtype}}^{\ast }]$

• $\mathrm{mems}({\mathit{externtype}}^{\ast })=[\mathit{memtype}|(\mathsf{mem}\mathit{memtype})\in {\mathit{externtype}}^{\ast }]$

• $\mathrm{globals}({\mathit{externtype}}^{\ast })=[\mathit{globaltype}|(\mathsf{global}\mathit{globaltype})\in {\mathit{externtype}}^{\ast }]$