Instructions

Instructions are classified by stack types $[t_1^{\ast }]\to [t_2^{\ast }]$ that describe how instructions manipulate the operand stack.

$$\begin{array}{r}\begin{array}{llll}& \mathit{stacktype}& ::=& [{\mathit{opdtype}}^{\ast }]\to [{\mathit{opdtype}}^{\ast }]\\ & \mathit{opdtype}& ::=& \mathit{valtype}|\mathrm{\perp }\end{array}\end{array}$$

The types describe the required input stack with operand 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. Stack types are akin to function types, except that they allow individual operands to be classified as $\mathrm{\perp }$ (bottom), indicating that the type is unconstrained. As an auxiliary notion, an operand type $t_1$ matches another operand type $t_2$, if $t_1$ is either $\mathrm{\perp }$ or equal to $t_2$. This is extended to stack types in a point-wise manner.

$$\frac{}{⊢t\le t}\frac{}{⊢\mathrm{\perp }\le t}$$

$$\frac{(⊢t\le t^{\prime }{)}^{\ast }}{⊢[t^{\ast }]\le [{t^{\prime }}^{\ast }]}$$

Note

For example, the instruction $\mathsf{i}\mathsf{32}.\mathsf{add}$ has type $[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]$, consuming two $\mathsf{i}\mathsf{32}$ values and producing one.

Typing extends to instruction sequences ${\mathit{instr}}^{\ast }$. Such a sequence has a stack type $[t_1^{\ast }]\to [t_2^{\ast }]$ if the accumulative effect of executing the instructions is consuming values of types $t_1^{\ast }$ off the operand stack and pushing new values of types $t_2^{\ast }$.

For some instructions, the typing rules do not fully constrain the type, and therefore allow for multiple types. Such instructions are called polymorphic. Two degrees of polymorphism can be distinguished:

• value-polymorphic: the value type $t$ of one or several individual operands is unconstrained. That is the case for all parametric instructions like $\mathsf{drop}$ and $\mathsf{select}$.

• stack-polymorphic: the entire (or most of the) stack type $[t_1^{\ast }]\to [t_2^{\ast }]$ of the instruction is unconstrained. That is the case for all control instructions that perform an unconditional control transfer, such as $\mathsf{unreachable}$, $\mathsf{br}$, $\mathsf{br}\mathsf{\_}\mathsf{table}$, and $\mathsf{return}$.

In both cases, the unconstrained types or type sequences can be chosen arbitrarily, as long as they meet the constraints imposed for the surrounding parts of the program.

Note

For example, the $\mathsf{select}$ instruction is valid with type $[tt\mathsf{i}\mathsf{32}]\to [t]$, for any possible number type $t$. Consequently, both instruction sequences

$$(\mathsf{i}\mathsf{32}.\mathsf{const}1)(\mathsf{i}\mathsf{32}.\mathsf{const}2)(\mathsf{i}\mathsf{32}.\mathsf{const}3)\mathsf{select}$$

and

$$(\mathsf{f}\mathsf{64}.\mathsf{const}1.0)(\mathsf{f}\mathsf{64}.\mathsf{const}2.0)(\mathsf{i}\mathsf{32}.\mathsf{const}3)\mathsf{select}$$

are valid, with $t$ in the typing of $\mathsf{select}$ being instantiated to $\mathsf{i}\mathsf{32}$ or $\mathsf{f}\mathsf{64}$, respectively.

The $\mathsf{unreachable}$ instruction is valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$ for any possible sequences of operand types $t_1^{\ast }$ and $t_2^{\ast }$. Consequently,

$$\mathsf{unreachable}\mathsf{i}\mathsf{32}.\mathsf{add}$$

is valid by assuming type $[]\to [\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]$ for the $\mathsf{unreachable}$ instruction. In contrast,

$$\mathsf{unreachable}(\mathsf{i}\mathsf{64}.\mathsf{const}0)\mathsf{i}\mathsf{32}.\mathsf{add}$$

is invalid, because there is no possible type to pick for the $\mathsf{unreachable}$ instruction that would make the sequence well-typed.

The Appendix describes a type checking algorithm that efficiently implements validation of instruction sequences as prescribed by the rules given here.

Numeric Instructions

$t\mathsf{.}\mathsf{const}c$

• The instruction is valid with type $[]\to [t]$.

$$\frac{}{C⊢t\mathsf{.}\mathsf{const}c:[]\to [t]}$$

$t\mathsf{.}\mathit{unop}$

• The instruction is valid with type $[t]\to [t]$.

$$\frac{}{C⊢t\mathsf{.}\mathit{unop}:[t]\to [t]}$$

$t\mathsf{.}\mathit{binop}$

• The instruction is valid with type $[tt]\to [t]$.

$$\frac{}{C⊢t\mathsf{.}\mathit{binop}:[tt]\to [t]}$$

$t\mathsf{.}\mathit{testop}$

• The instruction is valid with type $[t]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢t\mathsf{.}\mathit{testop}:[t]\to [\mathsf{i}\mathsf{32}]}$$

$t\mathsf{.}\mathit{relop}$

• The instruction is valid with type $[tt]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢t\mathsf{.}\mathit{relop}:[tt]\to [\mathsf{i}\mathsf{32}]}$$

$t_2\mathsf{.}\mathit{cvtop}\mathsf{\_}{t}_1\mathsf{\_}{\mathit{sx}}^{?}$

• The instruction is valid with type $[t_1]\to [t_2]$.

$$\frac{}{C⊢t_2\mathsf{.}\mathit{cvtop}\mathsf{\_}{t}_1\mathsf{\_}{\mathit{sx}}^{?}:[t_1]\to [t_2]}$$

Reference Instructions

$\mathsf{ref}\mathsf{.}\mathsf{null}t$

• The instruction is valid with type $[]\to [t]$.

$$\frac{}{C⊢\mathsf{ref}\mathsf{.}\mathsf{null}t:[]\to [t]}$$

Note

In future versions of WebAssembly, there may be reference types for which no null reference is allowed.

$\mathsf{ref}\mathsf{.}\mathsf{is}\mathsf{\_}\mathsf{null}$

• The instruction is valid with type $[t]\to [\mathsf{i}\mathsf{32}]$, for any reference type $t$.

$$\frac{t=\mathit{reftype}}{C⊢\mathsf{ref}\mathsf{.}\mathsf{is}\mathsf{\_}\mathsf{null}:[t]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{ref}\mathsf{.}\mathsf{func}x$

• The function $C.\mathsf{funcs}[x]$ must be defined in the context.

• The function index $x$ must be contained in $C.\mathsf{refs}$.

• The instruction is valid with type $[]\to [\mathsf{funcref}]$.

$$\frac{C.\mathsf{funcs}[x]=\mathit{functype}x\in C.\mathsf{refs}}{C⊢\mathsf{ref}\mathsf{.}\mathsf{func}x:[]\to [\mathsf{funcref}]}$$

Vector Instructions

Vector instructions can have a prefix to describe the shape of the operand. Packed numeric types, $\mathsf{i}\mathsf{8}$ and $\mathsf{i}\mathsf{16}$, are not value types. An auxiliary function maps such packed type shapes to value types:

$$\begin{array}{r}\begin{array}{lll}\mathrm{unpacked}(\mathsf{i}\mathsf{8}\mathsf{x}\mathsf{16})& =& \mathsf{i}\mathsf{32}\\ \mathrm{unpacked}(\mathsf{i}\mathsf{16}\mathsf{x}\mathsf{8})& =& \mathsf{i}\mathsf{32}\\ \mathrm{unpacked}(t\mathsf{x}N)& =& t\end{array}\end{array}$$

The following auxiliary function denotes the number of lanes in a vector shape, i.e., its dimension:

$$\begin{array}{lll}\dim (t\mathsf{x}N)& =& N\end{array}$$

$\mathsf{v}\mathsf{128}\mathsf{.}\mathsf{const}c$

• The instruction is valid with type $[]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathsf{v}\mathsf{128}\mathsf{.}\mathsf{const}c:[]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvunop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvunop}:[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvbinop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvbinop}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvternop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvternop}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvtestop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢\mathsf{v}\mathsf{128}\mathsf{.}\mathit{vvtestop}:[\mathsf{v}\mathsf{128}]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{i}\mathsf{8}\mathsf{x}\mathsf{16.}\mathsf{swizzle}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathsf{i}\mathsf{8}\mathsf{x}\mathsf{16.}\mathsf{swizzle}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{i}\mathsf{8}\mathsf{x}\mathsf{16.}\mathsf{shuffle}{\mathit{laneidx}}^{16}$

• For all ${\mathit{laneidx}}_i$, in ${\mathit{laneidx}}^{16}$, ${\mathit{laneidx}}_i$ must be smaller than $32$.

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{(\mathit{laneidx}<32{)}^{16}}{C⊢\mathsf{i}\mathsf{8}\mathsf{x}\mathsf{16.}\mathsf{shuffle}{\mathit{laneidx}}^{16}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{shape}\mathsf{.}\mathsf{splat}$

• Let $t$ be $\mathrm{unpacked}(\mathit{shape})$.

• The instruction is valid with type $[t]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathit{shape}\mathsf{.}\mathsf{splat}:[\mathrm{unpacked}(\mathit{shape})]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{shape}\mathsf{.}\mathsf{extract}\mathsf{\_}\mathsf{lane}\mathsf{\_}{\mathit{sx}}^{?}\mathit{laneidx}$

• The lane index $\mathit{laneidx}$ must be smaller than $\dim (\mathit{shape})$.

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathrm{unpacked}(\mathit{shape})]$.

$$\frac{\mathit{laneidx}<\dim (\mathit{shape})}{C⊢t\mathsf{x}N\mathsf{.}\mathsf{extract}\mathsf{\_}\mathsf{lane}\mathsf{\_}{\mathit{sx}}^{?}\mathit{laneidx}:[\mathsf{v}\mathsf{128}]\to [\mathrm{unpacked}(\mathit{shape})]}$$

$\mathit{shape}\mathsf{.}\mathsf{replace}\mathsf{\_}\mathsf{lane}\mathit{laneidx}$

• The lane index $\mathit{laneidx}$ must be smaller than $\dim (\mathit{shape})$.

• Let $t$ be $\mathrm{unpacked}(\mathit{shape})$.

• The instruction is valid with type $[\mathsf{v}\mathsf{128}t]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{\mathit{laneidx}<\dim (\mathit{shape})}{C⊢\mathit{shape}\mathsf{.}\mathsf{replace}\mathsf{\_}\mathsf{lane}\mathit{laneidx}:[\mathsf{v}\mathsf{128}\mathrm{unpacked}(\mathit{shape})]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{shape}\mathsf{.}\mathit{vunop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathit{shape}\mathsf{.}\mathit{vunop}:[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{shape}\mathsf{.}\mathit{vbinop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathit{shape}\mathsf{.}\mathit{vbinop}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{shape}\mathsf{.}\mathit{vrelop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathit{shape}\mathsf{.}\mathit{vrelop}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{ishape}\mathsf{.}\mathit{vishiftop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathit{ishape}\mathsf{.}\mathit{vishiftop}:[\mathsf{v}\mathsf{128}\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{shape}\mathsf{.}\mathit{vtestop}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢\mathit{shape}\mathsf{.}\mathit{vtestop}:[\mathsf{v}\mathsf{128}]\to [\mathsf{i}\mathsf{32}]}$$

$\mathit{shape}\mathsf{.}\mathit{vcvtop}\mathsf{\_}{\mathit{half}}^{?}\mathsf{\_}\mathit{shape}\mathsf{\_}{\mathit{sx}}^{?}{\mathsf{\_}\mathsf{zero}}^{?}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢\mathit{shape}\mathsf{.}\mathit{vcvtop}\mathsf{\_}{\mathit{half}}^{?}\mathsf{\_}\mathit{shape}\mathsf{\_}{\mathit{sx}}^{?}{\mathsf{\_}\mathsf{zero}}^{?}:[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

${\mathit{ishape}}_1\mathsf{.}\mathsf{narrow}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathit{sx}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢{\mathit{ishape}}_1\mathsf{.}\mathsf{narrow}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathit{sx}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathit{ishape}\mathsf{.}\mathsf{bitmask}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢\mathit{ishape}\mathsf{.}\mathsf{bitmask}:[\mathsf{v}\mathsf{128}]\to [\mathsf{i}\mathsf{32}]}$$

${\mathit{ishape}}_1\mathsf{.}\mathsf{dot}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathsf{s}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢{\mathit{ishape}}_1\mathsf{.}\mathsf{dot}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathsf{s}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

${\mathit{ishape}}_1\mathsf{.}\mathsf{extmul}\mathsf{\_}\mathit{half}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathit{sx}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢{\mathit{ishape}}_1\mathsf{.}\mathsf{extmul}\mathsf{\_}\mathit{half}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathit{sx}:[\mathsf{v}\mathsf{128}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

${\mathit{ishape}}_1\mathsf{.}\mathsf{extadd}\mathsf{\_}\mathsf{pairwise}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathit{sx}$

• The instruction is valid with type $[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{}{C⊢{\mathit{ishape}}_1\mathsf{.}\mathsf{extadd}\mathsf{\_}\mathsf{pairwise}\mathsf{\_}{\mathit{ishape}}_2\mathsf{\_}\mathit{sx}:[\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

Parametric Instructions

$\mathsf{drop}$

• The instruction is valid with type $[t]\to []$, for any operand type $t$.

$$\frac{}{C⊢\mathsf{drop}:[t]\to []}$$

Note

Both $\mathsf{drop}$ and $\mathsf{select}$ without annotation are value-polymorphic instructions.

$\mathsf{select}(t^{\ast }{)}^{?}$

• If $t^{\ast }$ is present, then:

  • The length of $t^{\ast }$ must be $1$.

  • Then the instruction is valid with type $[t^{\ast }{t}^{\ast }\mathsf{i}\mathsf{32}]\to [t^{\ast }]$.

• Else:

  • The instruction is valid with type $[tt\mathsf{i}\mathsf{32}]\to [t]$, for any operand type $t$ that matches some number type or vector type.

$$\frac{}{C⊢\mathsf{select}t:[tt\mathsf{i}\mathsf{32}]\to [t]}\frac{⊢t\le \mathit{numtype}}{C⊢\mathsf{select}:[tt\mathsf{i}\mathsf{32}]\to [t]}\frac{⊢t\le \mathit{vectype}}{C⊢\mathsf{select}:[tt\mathsf{i}\mathsf{32}]\to [t]}$$

Note

In future versions of WebAssembly, $\mathsf{select}$ may allow more than one value per choice.

Variable Instructions

$\mathsf{local}\mathsf{.}\mathsf{get}x$

• The local $C.\mathsf{locals}[x]$ must be defined in the context.

• Let $t$ be the value type $C.\mathsf{locals}[x]$.

• Then the instruction is valid with type $[]\to [t]$.

$$\frac{C.\mathsf{locals}[x]=t}{C⊢\mathsf{local}\mathsf{.}\mathsf{get}x:[]\to [t]}$$

$\mathsf{local}\mathsf{.}\mathsf{set}x$

• The local $C.\mathsf{locals}[x]$ must be defined in the context.

• Let $t$ be the value type $C.\mathsf{locals}[x]$.

• Then the instruction is valid with type $[t]\to []$.

$$\frac{C.\mathsf{locals}[x]=t}{C⊢\mathsf{local}\mathsf{.}\mathsf{set}x:[t]\to []}$$

$\mathsf{local}\mathsf{.}\mathsf{tee}x$

• The local $C.\mathsf{locals}[x]$ must be defined in the context.

• Let $t$ be the value type $C.\mathsf{locals}[x]$.

• Then the instruction is valid with type $[t]\to [t]$.

$$\frac{C.\mathsf{locals}[x]=t}{C⊢\mathsf{local}\mathsf{.}\mathsf{tee}x:[t]\to [t]}$$

$\mathsf{global}\mathsf{.}\mathsf{get}x$

• The global $C.\mathsf{globals}[x]$ must be defined in the context.

• Let $\mathit{mut}t$ be the global type $C.\mathsf{globals}[x]$.

• Then the instruction is valid with type $[]\to [t]$.

$$\frac{C.\mathsf{globals}[x]=\mathit{mut}t}{C⊢\mathsf{global}\mathsf{.}\mathsf{get}x:[]\to [t]}$$

$\mathsf{global}\mathsf{.}\mathsf{set}x$

• The global $C.\mathsf{globals}[x]$ must be defined in the context.

• Let $\mathit{mut}t$ be the global type $C.\mathsf{globals}[x]$.

• The mutability $\mathit{mut}$ must be $\mathsf{var}$.

• Then the instruction is valid with type $[t]\to []$.

$$\frac{C.\mathsf{globals}[x]=\mathsf{var}t}{C⊢\mathsf{global}\mathsf{.}\mathsf{set}x:[t]\to []}$$

Table Instructions

$\mathsf{table}\mathsf{.}\mathsf{get}x$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Let $\mathit{limits}t$ be the table type $C.\mathsf{tables}[x]$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [t]$.

$$\frac{C.\mathsf{tables}[x]=\mathit{limits}t}{C⊢\mathsf{table}\mathsf{.}\mathsf{get}x:[\mathsf{i}\mathsf{32}]\to [t]}$$

$\mathsf{table}\mathsf{.}\mathsf{set}x$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Let $\mathit{limits}t$ be the table type $C.\mathsf{tables}[x]$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t]\to []$.

$$\frac{C.\mathsf{tables}[x]=\mathit{limits}t}{C⊢\mathsf{table}\mathsf{.}\mathsf{set}x:[\mathsf{i}\mathsf{32}t]\to []}$$

$\mathsf{table}\mathsf{.}\mathsf{size}x$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Then the instruction is valid with type $[]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{C.\mathsf{tables}[x]=\mathit{tabletype}}{C⊢\mathsf{table}\mathsf{.}\mathsf{size}x:[]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{table}\mathsf{.}\mathsf{grow}x$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Let $\mathit{limits}t$ be the table type $C.\mathsf{tables}[x]$.

• Then the instruction is valid with type $[t\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{C.\mathsf{tables}[x]=\mathit{limits}t}{C⊢\mathsf{table}\mathsf{.}\mathsf{grow}x:[t\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{table}\mathsf{.}\mathsf{fill}x$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Let $\mathit{limits}t$ be the table type $C.\mathsf{tables}[x]$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t\mathsf{i}\mathsf{32}]\to []$.

$$\frac{C.\mathsf{tables}[x]=\mathit{limits}t}{C⊢\mathsf{table}\mathsf{.}\mathsf{fill}x:[\mathsf{i}\mathsf{32}t\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{table}\mathsf{.}\mathsf{copy}xy$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Let ${\mathit{limits}}_1{t}_1$ be the table type $C.\mathsf{tables}[x]$.

• The table $C.\mathsf{tables}[y]$ must be defined in the context.

• Let ${\mathit{limits}}_2{t}_2$ be the table type $C.\mathsf{tables}[y]$.

• The reference type $t_1$ must be the same as $t_2$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{C.\mathsf{tables}[x]={\mathit{limits}}_{1}tC.\mathsf{tables}[y]={\mathit{limits}}_{2}t}{C⊢\mathsf{table}\mathsf{.}\mathsf{copy}xy:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{table}\mathsf{.}\mathsf{init}xy$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Let $\mathit{limits}{t}_1$ be the table type $C.\mathsf{tables}[x]$.

• The element segment $C.\mathsf{elems}[y]$ must be defined in the context.

• Let $t_2$ be the reference type $C.\mathsf{elems}[y]$.

• The reference type $t_1$ must be the same as $t_2$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{C.\mathsf{tables}[x]=\mathit{limits}tC.\mathsf{elems}[y]=t}{C⊢\mathsf{table}\mathsf{.}\mathsf{init}xy:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{elem}\mathsf{.}\mathsf{drop}x$

• The element segment $C.\mathsf{elems}[x]$ must be defined in the context.

• Then the instruction is valid with type $[]\to []$.

$$\frac{C.\mathsf{elems}[x]=t}{C⊢\mathsf{elem}\mathsf{.}\mathsf{drop}x:[]\to []}$$

Memory Instructions

$t\mathsf{.}\mathsf{load}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than the bit width of $t$ divided by $8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}\le |t|/8}{C⊢t\mathsf{.}\mathsf{load}\mathit{memarg}:[\mathsf{i}\mathsf{32}]\to [t]}$$

$t\mathsf{.}\mathsf{load}N\mathsf{\_}\mathit{sx}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}\le N/8}{C⊢t\mathsf{.}\mathsf{load}N\mathsf{\_}\mathit{sx}\mathit{memarg}:[\mathsf{i}\mathsf{32}]\to [t]}$$

$t\mathsf{.}\mathsf{store}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than the bit width of $t$ divided by $8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t]\to []$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}\le |t|/8}{C⊢t\mathsf{.}\mathsf{store}\mathit{memarg}:[\mathsf{i}\mathsf{32}t]\to []}$$

$t\mathsf{.}\mathsf{store}N\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t]\to []$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}\le N/8}{C⊢t\mathsf{.}\mathsf{store}N\mathit{memarg}:[\mathsf{i}\mathsf{32}t]\to []}$$

$\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{x}M\mathrm{\_}\mathit{sx}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than $N/8\cdot M$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}\le N/8\cdot M}{C⊢\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{x}M\mathrm{\_}\mathit{sx}\mathit{memarg}:[\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{\_}\mathsf{splat}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}\le N/8}{C⊢\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{\_}\mathsf{splat}\mathit{memarg}:[\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{\_}\mathsf{zero}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}\le N/8}{C⊢\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{\_}\mathsf{zero}\mathit{memarg}:[\mathsf{i}\mathsf{32}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{\_}\mathsf{lane}\mathit{memarg}\mathit{laneidx}$

• The lane index $\mathit{laneidx}$ must be smaller than $128/N$.

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{\mathit{laneidx}<128/NC.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}<N/8}{C⊢\mathsf{v}\mathsf{128.}\mathsf{load}N\mathsf{\_}\mathsf{lane}\mathit{memarg}\mathit{laneidx}:[\mathsf{i}\mathsf{32}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]}$$

$\mathsf{v}\mathsf{128.}\mathsf{store}N\mathsf{\_}\mathsf{lane}\mathit{memarg}\mathit{laneidx}$

• The lane index $\mathit{laneidx}$ must be smaller than $128/N$.

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must not be larger than $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{v}\mathsf{128}]\to [\mathsf{v}\mathsf{128}]$.

$$\frac{\mathit{laneidx}<128/NC.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}<N/8}{C⊢\mathsf{v}\mathsf{128.}\mathsf{store}N\mathsf{\_}\mathsf{lane}\mathit{memarg}\mathit{laneidx}:[\mathsf{i}\mathsf{32}\mathsf{v}\mathsf{128}]\to []}$$

$\mathsf{memory}\mathsf{.}\mathsf{size}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• Then the instruction is valid with type $[]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}}{C⊢\mathsf{memory}\mathsf{.}\mathsf{size}:[]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{memory}\mathsf{.}\mathsf{grow}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}}{C⊢\mathsf{memory}\mathsf{.}\mathsf{grow}:[\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{memory}\mathsf{.}\mathsf{fill}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}}{C⊢\mathsf{memory}\mathsf{.}\mathsf{fill}:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{memory}\mathsf{.}\mathsf{copy}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}}{C⊢\mathsf{memory}\mathsf{.}\mathsf{copy}:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{memory}\mathsf{.}\mathsf{init}x$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The data segment $C.\mathsf{datas}[x]$ must be defined in the context.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}C.\mathsf{datas}[x]=\text{ok}}{C⊢\mathsf{memory}\mathsf{.}\mathsf{init}x:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{data}\mathsf{.}\mathsf{drop}x$

• The data segment $C.\mathsf{datas}[x]$ must be defined in the context.

• Then the instruction is valid with type $[]\to []$.

$$\frac{C.\mathsf{datas}[x]=\text{ok}}{C⊢\mathsf{data}\mathsf{.}\mathsf{drop}x:[]\to []}$$

Atomic Memory Instructions

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{load}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to the width of $t$ divided by $8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=|t|/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{load}\mathit{memarg}:[\mathsf{i}\mathsf{32}]\to [t]}$$

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{load}N\mathsf{\_}\mathsf{u}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=N/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{load}N\mathsf{\_}\mathsf{u}\mathit{memarg}:[\mathsf{i}\mathsf{32}]\to [t]}$$

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{store}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to the width of $t$ divided by $8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t]\to []$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=|t|/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{store}\mathit{memarg}:[\mathsf{i}\mathsf{32}t]\to []}$$

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{store}N\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t]\to []$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=N/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{store}N\mathit{memarg}:[\mathsf{i}\mathsf{32}t]\to []}$$

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}\mathsf{.}\mathit{atop}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to the width of $t$ divided by $8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=|t|/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}\mathsf{.}\mathit{atop}\mathit{memarg}:[\mathsf{i}\mathsf{32}t]\to [t]}$$

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}N\mathsf{.}\mathit{atop}\mathsf{\_}\mathsf{u}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}t]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=N/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}N\mathsf{.}\mathit{atop}\mathsf{\_}\mathsf{u}\mathit{memarg}:[\mathsf{i}\mathsf{32}t]\to [t]}$$

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}\mathsf{.}\mathsf{cmpxchg}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to the width of $t$ divided by $8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}tt]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=|t|/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}\mathsf{.}\mathsf{cmpxchg}\mathit{memarg}:[\mathsf{i}\mathsf{32}tt]\to [t]}$$

$t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}N\mathsf{.}\mathsf{cmpxchg}\mathsf{\_}\mathsf{u}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to $N/8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}tt]\to [t]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=N/8}{C⊢t\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{rmw}N\mathsf{.}\mathsf{cmpxchg}\mathsf{\_}\mathsf{u}\mathit{memarg}:[\mathsf{i}\mathsf{32}tt]\to [t]}$$

$\mathsf{memory}\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{notify}\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• Let $\mathit{limits}\mathit{share}$ be the memory type $C.\mathsf{mems}[0]$.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to $4$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=4}{C⊢\mathsf{memory}\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{notify}\mathit{memarg}:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{memory}\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{wait}N\mathit{memarg}$

• The memory $C.\mathsf{mems}[0]$ must be defined in the context.

• Let $\mathit{limits}\mathit{share}$ be the memory type $C.\mathsf{mems}[0]$.

• The alignment $2^{\mathit{memarg}.\mathsf{align}}$ must be equal to $N$ divided by $8$.

• Then the instruction is valid with type $[\mathsf{i}\mathsf{32}\mathsf{i}N\mathsf{i}\mathsf{64}]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{C.\mathsf{mems}[0]=\mathit{memtype}{2}^{\mathit{memarg}.\mathsf{align}}=N/8}{C⊢\mathsf{memory}\mathsf{.}\mathsf{atomic}\mathsf{.}\mathsf{wait}N\mathit{memarg}:[\mathsf{i}\mathsf{32}\mathsf{i}N\mathsf{i}\mathsf{64}]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{atomic}\mathsf{.}\mathsf{fence}$

• The instruction is valid with type $[]\to []$.

$$\frac{}{C⊢\mathsf{atomic}\mathsf{.}\mathsf{fence}:[]\to []}$$

Note

The $\mathsf{atomic}\mathsf{.}\mathsf{fence}$ instruction may occur in modules which declare no memory without causing a validation error.

Control Instructions

$\mathsf{nop}$

• The instruction is valid with type $[]\to []$.

$$\frac{}{C⊢\mathsf{nop}:[]\to []}$$

$\mathsf{unreachable}$

• The instruction is valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$, for any sequences of operand types $t_1^{\ast }$ and $t_2^{\ast }$.

$$\frac{}{C⊢\mathsf{unreachable}:[t_1^{\ast }]\to [t_2^{\ast }]}$$

Note

The $\mathsf{unreachable}$ instruction is stack-polymorphic.

$\mathsf{block}\mathit{blocktype}{\mathit{instr}}^{\ast }\mathsf{end}$

• The block type must be valid as some function type $[t_1^{\ast }]\to [t_2^{\ast }]$.

• Let $C^{\prime }$ be the same context as $C$, but with the result type $[t_2^{\ast }]$ prepended to the $\mathsf{labels}$ vector.

• Under context $C^{\prime }$, the instruction sequence ${\mathit{instr}}^{\ast }$ must be valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$.

• Then the compound instruction is valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$.

$$\frac{C⊢\mathit{blocktype}:[t_1^{\ast }]\to [t_2^{\ast }]C,\mathsf{labels}[t_2^{\ast }]⊢{\mathit{instr}}^{\ast }:[t_1^{\ast }]\to [t_2^{\ast }]}{C⊢\mathsf{block}\mathit{blocktype}{\mathit{instr}}^{\ast }\mathsf{end}:[t_1^{\ast }]\to [t_2^{\ast }]}$$

Note

The notation $C,\mathsf{labels}[t^{\ast }]$ inserts the new label type at index $0$, shifting all others.

$\mathsf{loop}\mathit{blocktype}{\mathit{instr}}^{\ast }\mathsf{end}$

• The block type must be valid as some function type $[t_1^{\ast }]\to [t_2^{\ast }]$.

• Let $C^{\prime }$ be the same context as $C$, but with the result type $[t_1^{\ast }]$ prepended to the $\mathsf{labels}$ vector.

• Under context $C^{\prime }$, the instruction sequence ${\mathit{instr}}^{\ast }$ must be valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$.

• Then the compound instruction is valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$.

$$\frac{C⊢\mathit{blocktype}:[t_1^{\ast }]\to [t_2^{\ast }]C,\mathsf{labels}[t_1^{\ast }]⊢{\mathit{instr}}^{\ast }:[t_1^{\ast }]\to [t_2^{\ast }]}{C⊢\mathsf{loop}\mathit{blocktype}{\mathit{instr}}^{\ast }\mathsf{end}:[t_1^{\ast }]\to [t_2^{\ast }]}$$

Note

The notation $C,\mathsf{labels}[t^{\ast }]$ inserts the new label type at index $0$, shifting all others.

$\mathsf{if}\mathit{blocktype}{\mathit{instr}}_1^{\ast }\mathsf{else}{\mathit{instr}}_2^{\ast }\mathsf{end}$

• The block type must be valid as some function type $[t_1^{\ast }]\to [t_2^{\ast }]$.

• Let $C^{\prime }$ be the same context as $C$, but with the result type $[t_2^{\ast }]$ prepended to the $\mathsf{labels}$ vector.

• Under context $C^{\prime }$, the instruction sequence ${\mathit{instr}}_1^{\ast }$ must be valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$.

• Under context $C^{\prime }$, the instruction sequence ${\mathit{instr}}_2^{\ast }$ must be valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$.

• Then the compound instruction is valid with type $[t_1^{\ast }\mathsf{i}\mathsf{32}]\to [t_2^{\ast }]$.

$$\frac{C⊢\mathit{blocktype}:[t_1^{\ast }]\to [t_2^{\ast }]C,\mathsf{labels}[t_2^{\ast }]⊢{\mathit{instr}}_1^{\ast }:[t_1^{\ast }]\to [t_2^{\ast }]C,\mathsf{labels}[t_2^{\ast }]⊢{\mathit{instr}}_2^{\ast }:[t_1^{\ast }]\to [t_2^{\ast }]}{C⊢\mathsf{if}\mathit{blocktype}{\mathit{instr}}_1^{\ast }\mathsf{else}{\mathit{instr}}_2^{\ast }\mathsf{end}:[t_1^{\ast }\mathsf{i}\mathsf{32}]\to [t_2^{\ast }]}$$

Note

The notation $C,\mathsf{labels}[t^{\ast }]$ inserts the new label type at index $0$, shifting all others.

$\mathsf{br}l$

• The label $C.\mathsf{labels}[l]$ must be defined in the context.

• Let $[t^{\ast }]$ be the result type $C.\mathsf{labels}[l]$.

• Then the instruction is valid with type $[t_1^{\ast }{t}^{\ast }]\to [t_2^{\ast }]$, for any sequences of operand types $t_1^{\ast }$ and $t_2^{\ast }$.

$$\frac{C.\mathsf{labels}[l]=[t^{\ast }]}{C⊢\mathsf{br}l:[t_1^{\ast }{t}^{\ast }]\to [t_2^{\ast }]}$$

Note

The label index space in the context $C$ contains the most recent label first, so that $C.\mathsf{labels}[l]$ performs a relative lookup as expected.

The $\mathsf{br}$ instruction is stack-polymorphic.

$\mathsf{br}\mathsf{\_}\mathsf{if}l$

• The label $C.\mathsf{labels}[l]$ must be defined in the context.

• Let $[t^{\ast }]$ be the result type $C.\mathsf{labels}[l]$.

• Then the instruction is valid with type $[t^{\ast }\mathsf{i}\mathsf{32}]\to [t^{\ast }]$.

$$\frac{C.\mathsf{labels}[l]=[t^{\ast }]}{C⊢\mathsf{br}\mathsf{\_}\mathsf{if}l:[t^{\ast }\mathsf{i}\mathsf{32}]\to [t^{\ast }]}$$

Note

The label index space in the context $C$ contains the most recent label first, so that $C.\mathsf{labels}[l]$ performs a relative lookup as expected.

$\mathsf{br}\mathsf{\_}\mathsf{table}{l}^{\ast }{l}_N$

• The label $C.\mathsf{labels}[l_N]$ must be defined in the context.

• For all $l_i$ in $l^{\ast }$, the label $C.\mathsf{labels}[l_i]$ must be defined in the context.

• There must be a sequence $t^{\ast }$ of operand types, such that:

  • For each operand type $t_j$ in $t^{\ast }$ and corresponding type $t_{Nj}^{\prime }$ in $C.\mathsf{labels}[l_N]$, $t_j$ matches $t_{Nj}^{\prime }$.

  • For all $l_i$ in $l^{\ast }$, and for each operand type $t_j$ in $t^{\ast }$ and corresponding type $t_{ij}^{\prime }$ in $C.\mathsf{labels}[l_i]$, $t_j$ matches $t_{ij}^{\prime }$.

• Then the instruction is valid with type $[t_1^{\ast }{t}^{\ast }\mathsf{i}\mathsf{32}]\to [t_2^{\ast }]$, for any sequences of operand types $t_1^{\ast }$ and $t_2^{\ast }$.

$$\frac{(⊢[t^{\ast }]\le C.\mathsf{labels}[l]{)}^{\ast }⊢[t^{\ast }]\le C.\mathsf{labels}[l_N]}{C⊢\mathsf{br}\mathsf{\_}\mathsf{table}{l}^{\ast }{l}_N:[t_1^{\ast }{t}^{\ast }\mathsf{i}\mathsf{32}]\to [t_2^{\ast }]}$$

Note

The label index space in the context $C$ contains the most recent label first, so that $C.\mathsf{labels}[l_i]$ performs a relative lookup as expected.

The $\mathsf{br}\mathsf{\_}\mathsf{table}$ instruction is stack-polymorphic.

$\mathsf{return}$

• The return type $C.\mathsf{return}$ must not be absent in the context.

• Let $[t^{\ast }]$ be the result type of $C.\mathsf{return}$.

• Then the instruction is valid with type $[t_1^{\ast }{t}^{\ast }]\to [t_2^{\ast }]$, for any sequences of operand types $t_1^{\ast }$ and $t_2^{\ast }$.

$$\frac{C.\mathsf{return}=[t^{\ast }]}{C⊢\mathsf{return}:[t_1^{\ast }{t}^{\ast }]\to [t_2^{\ast }]}$$

Note

The $\mathsf{return}$ instruction is stack-polymorphic.

$C.\mathsf{return}$ is absent (set to $ϵ$) when validating an expression that is not a function body. This differs from it being set to the empty result type ($[ϵ]$), which is the case for functions not returning anything.

$\mathsf{call}x$

• The function $C.\mathsf{funcs}[x]$ must be defined in the context.

• Then the instruction is valid with type $C.\mathsf{funcs}[x]$.

$$\frac{C.\mathsf{funcs}[x]=[t_1^{\ast }]\to [t_2^{\ast }]}{C⊢\mathsf{call}x:[t_1^{\ast }]\to [t_2^{\ast }]}$$

$\mathsf{call}\mathsf{\_}\mathsf{indirect}xy$

• The table $C.\mathsf{tables}[x]$ must be defined in the context.

• Let $\mathit{limits}t$ be the table type $C.\mathsf{tables}[x]$.

• The reference type $t$ must be $\mathsf{funcref}$.

• The type $C.\mathsf{types}[y]$ must be defined in the context.

• Let $[t_1^{\ast }]\to [t_2^{\ast }]$ be the function type $C.\mathsf{types}[y]$.

• Then the instruction is valid with type $[t_1^{\ast }\mathsf{i}\mathsf{32}]\to [t_2^{\ast }]$.

$$\frac{C.\mathsf{tables}[x]=\mathit{limits}\mathsf{funcref}C.\mathsf{types}[y]=[t_1^{\ast }]\to [t_2^{\ast }]}{C⊢\mathsf{call}\mathsf{\_}\mathsf{indirect}xy:[t_1^{\ast }\mathsf{i}\mathsf{32}]\to [t_2^{\ast }]}$$

Instruction Sequences

Typing of instruction sequences is defined recursively.

Empty Instruction Sequence: $ϵ$

• The empty instruction sequence is valid with type $[t^{\ast }]\to [t^{\ast }]$, for any sequence of operand types $t^{\ast }$.

$$\frac{}{C⊢ϵ:[t^{\ast }]\to [t^{\ast }]}$$

Non-empty Instruction Sequence: ${\mathit{instr}}^{\ast }{\mathit{instr}}_N$

• The instruction sequence ${\mathit{instr}}^{\ast }$ must be valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$, for some sequences of operand types $t_1^{\ast }$ and $t_2^{\ast }$.

• The instruction ${\mathit{instr}}_N$ must be valid with type $[t^{\ast }]\to [t_3^{\ast }]$, for some sequences of operand types $t^{\ast }$ and $t_3^{\ast }$.

• There must be a sequence of operand types $t_0^{\ast }$, such that $t_2^{\ast }=t_0^{\ast }{t^{\prime }}^{\ast }$ where the type sequence ${t^{\prime }}^{\ast }$ is as long as $t^{\ast }$.

• For each operand type $t_i^{\prime }$ in ${t^{\prime }}^{\ast }$ and corresponding type $t_i$ in $t^{\ast }$, $t_i^{\prime }$ matches $t_i$.

• Then the combined instruction sequence is valid with type $[t_1^{\ast }]\to [t_0^{\ast }{t}_3^{\ast }]$.

$$\frac{C⊢{\mathit{instr}}^{\ast }:[t_1^{\ast }]\to [t_0^{\ast }{t^{\prime }}^{\ast }]⊢[{t^{\prime }}^{\ast }]\le [t^{\ast }]C⊢{\mathit{instr}}_N:[t^{\ast }]\to [t_3^{\ast }]}{C⊢{\mathit{instr}}^{\ast }{\mathit{instr}}_N:[t_1^{\ast }]\to [t_0^{\ast }{t}_3^{\ast }]}$$

Expressions

Expressions $\mathit{expr}$ are classified by result types of the form $[t^{\ast }]$.

${\mathit{instr}}^{\ast }\mathsf{end}$

• The instruction sequence ${\mathit{instr}}^{\ast }$ must be valid with some stack type $[]\to [{t^{\prime }}^{\ast }]$.

• For each operand type $t_i^{\prime }$ in ${t^{\prime }}^{\ast }$ and corresponding value type $t_i$ in $t^{\ast }$, $t_i^{\prime }$ matches $t_i$.

• Then the expression is valid with result type $[t^{\ast }]$.

$$\frac{C⊢{\mathit{instr}}^{\ast }:[]\to [{t^{\prime }}^{\ast }]⊢[{t^{\prime }}^{\ast }]\le [t^{\ast }]}{C⊢{\mathit{instr}}^{\ast }\mathsf{end}:[t^{\ast }]}$$

Constant Expressions

• In a constant expression ${\mathit{instr}}^{\ast }\mathsf{end}$ all instructions in ${\mathit{instr}}^{\ast }$ must be constant.

• A constant instruction $\mathit{instr}$ must be:

  • either of the form $t.\mathsf{const}c$,

  • or of the form $\mathsf{ref}\mathsf{.}\mathsf{null}$,

  • or of the form $\mathsf{ref}\mathsf{.}\mathsf{func}x$,

  • or of the form $\mathsf{global}\mathsf{.}\mathsf{get}x$, in which case $C.\mathsf{globals}[x]$ must be a global type of the form $\mathsf{const}t$.

$$\frac{(C⊢\mathit{instr}\text{const}{)}^{\ast }}{C⊢{\mathit{instr}}^{\ast }\mathsf{end}\text{const}}$$

$$\frac{}{C⊢t.\mathsf{const}c\text{const}}\frac{}{C⊢\mathsf{ref}\mathsf{.}\mathsf{null}t\text{const}}\frac{}{C⊢\mathsf{ref}\mathsf{.}\mathsf{func}x\text{const}}$$

$$\frac{C.\mathsf{globals}[x]=\mathsf{const}t}{C⊢\mathsf{global}\mathsf{.}\mathsf{get}x\text{const}}$$

Note

Currently, constant expressions occurring in globals, element, or data segments are further constrained in that contained $\mathsf{global}\mathsf{.}\mathsf{get}$ instructions are only allowed to refer to imported globals. This is enforced in the validation rule for modules by constraining the context $C$ accordingly.

The definition of constant expression may be extended in future versions of WebAssembly.