Instructions

Instructions are classified by instruction types that describe how they manipulate the operand stack and initialize locals: A 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. In most cases, this is empty.

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. The instruction $\mathsf{local}\mathsf{.}\mathsf{set}x$ has type $[t]{\to }_x[]$, provided $t$ is the type declared for the local $x$.

Typing extends to instruction sequences ${\mathit{instr}}^{\ast }$. Such a sequence has an instruction type $[t_1^{\ast }]{\to }_{x^{\ast }}[t_2^{\ast }]$ if the accumulative effect of executing the instructions is consuming values of types $t_1^{\ast }$ off the operand stack, pushing new values of types $t_2^{\ast }$, and setting all locals $x^{\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) instruction 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 stack-polymorphic, and hence valid with type $[t_1^{\ast }]\to [t_2^{\ast }]$ for any possible sequences of value 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}]$ 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}\mathit{ht}$

• The heap type $\mathit{ht}$ must be valid.

• Then the instruction is valid with type $[]\to [(\mathsf{ref}\mathsf{null}\mathit{ht})]$.

$$\frac{C⊢\mathit{ht}\text{ok}}{C⊢\mathsf{ref}\mathsf{.}\mathsf{null}\mathit{ht}:[]\to [(\mathsf{ref}\mathsf{null}\mathit{ht})]}$$

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

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

• Let $\mathit{dt}$ be the defined type $C.\mathsf{funcs}[x]$.

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

• The instruction is valid with type $[]\to [(\mathsf{ref}\mathit{dt})]$.

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

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

• The instruction is valid with type $[(\mathsf{ref}\mathsf{null}\mathit{ht})]\to [\mathsf{i}\mathsf{32}]$, for any valid heap type $\mathit{ht}$.

$$\frac{C⊢\mathit{ht}\text{ok}}{C⊢\mathsf{ref}\mathsf{.}\mathsf{is}\mathsf{\_}\mathsf{null}:[(\mathsf{ref}\mathsf{null}\mathit{ht})]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{ref}\mathsf{.}\mathsf{as}\mathsf{\_}\mathsf{non}\mathsf{\_}\mathsf{null}$

• The instruction is valid with type $[(\mathsf{ref}\mathsf{null}\mathit{ht})]\to [(\mathsf{ref}\mathit{ht})]$, for any valid heap type $\mathit{ht}$.

$$\frac{C⊢\mathit{ht}\text{ok}}{C⊢\mathsf{ref}\mathsf{.}\mathsf{as}\mathsf{\_}\mathsf{non}\mathsf{\_}\mathsf{null}:[(\mathsf{ref}\mathsf{null}\mathit{ht})]\to [(\mathsf{ref}\mathit{ht})]}$$

$\mathsf{ref}\mathsf{.}\mathsf{eq}$

• The instruction is valid with type $[(\mathsf{ref}\mathsf{null}\mathsf{eq})(\mathsf{ref}\mathsf{null}\mathsf{eq})]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢\mathsf{ref}\mathsf{.}\mathsf{eq}:[(\mathsf{ref}\mathsf{null}\mathsf{eq})(\mathsf{ref}\mathsf{null}\mathsf{eq})]\to [\mathsf{i}\mathsf{32}]}$$

$\mathsf{ref}\mathsf{.}\mathsf{test}\mathit{rt}$

• The reference type $\mathit{rt}$ must be valid.

• Then the instruction is valid with type $[{\mathit{rt}}^{\prime }]\to [\mathsf{i}\mathsf{32}]$ for any valid reference type ${\mathit{rt}}^{\prime }$ for which $\mathit{rt}$ matches ${\mathit{rt}}^{\prime }$.

$$\frac{C⊢\mathit{rt}\text{ok}C⊢{\mathit{rt}}^{\prime }\text{ok}C⊢\mathit{rt}\le {\mathit{rt}}^{\prime }}{C⊢\mathsf{ref}\mathsf{.}\mathsf{test}\mathit{rt}:[{\mathit{rt}}^{\prime }]\to [\mathsf{i}\mathsf{32}]}$$

Note

The liberty to pick a supertype ${\mathit{rt}}^{\prime }$ allows typing the instruction with the least precise super type of $\mathit{rt}$ as input, that is, the top type in the corresponding heap subtyping hierarchy.

$\mathsf{ref}\mathsf{.}\mathsf{cast}\mathit{rt}$

• The reference type $\mathit{rt}$ must be valid.

• Then the instruction is valid with type $[{\mathit{rt}}^{\prime }]\to [\mathit{rt}]$ for any valid reference type ${\mathit{rt}}^{\prime }$ for which $\mathit{rt}$ matches ${\mathit{rt}}^{\prime }$.

$$\frac{C⊢\mathit{rt}\text{ok}C⊢{\mathit{rt}}^{\prime }\text{ok}C⊢\mathit{rt}\le {\mathit{rt}}^{\prime }}{C⊢\mathsf{ref}\mathsf{.}\mathsf{cast}\mathit{rt}:[{\mathit{rt}}^{\prime }]\to [\mathit{rt}]}$$

Note

The liberty to pick a supertype ${\mathit{rt}}^{\prime }$ allows typing the instruction with the least precise super type of $\mathit{rt}$ as input, that is, the top type in the corresponding heap subtyping hierarchy.

Aggregate Reference Instructions

$\mathsf{struct}\mathsf{.}\mathsf{new}x$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be a structure type $\mathsf{struct}{\mathit{fieldtype}}^{\ast }$.

• For each field type ${\mathit{fieldtype}}_i$ in ${\mathit{fieldtype}}^{\ast }$:

  • Let ${\mathit{fieldtype}}_i$ be $\mathit{mut}{\mathit{storagetype}}_i$.

  • Let $t_i$ be the value type $\mathrm{unpack}({\mathit{storagetype}}_i)$.

• Let $t^{\ast }$ be the concatenation of all $t_i$.

• Then the instruction is valid with type $[t^{\ast }]\to [(\mathsf{ref}x)]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{struct}(\mathit{mut}\mathit{st}{)}^{\ast }}{C⊢\mathsf{struct}\mathsf{.}\mathsf{new}x:[(\mathrm{unpack}(\mathit{st}){)}^{\ast }]\to [(\mathsf{ref}x)]}$$

$\mathsf{struct}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{default}x$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be a structure type $\mathsf{struct}{\mathit{fieldtype}}^{\ast }$.

• For each field type ${\mathit{fieldtype}}_i$ in ${\mathit{fieldtype}}^{\ast }$:

  • Let ${\mathit{fieldtype}}_i$ be $\mathit{mut}{\mathit{storagetype}}_i$.

  • Let $t_i$ be the value type $\mathrm{unpack}({\mathit{storagetype}}_i)$.

  • The type $t_i$ must be defaultable.

• Let $t^{\ast }$ be the concatenation of all $t_i$.

• Then the instruction is valid with type $[]\to [(\mathsf{ref}x)]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{struct}(\mathit{mut}\mathit{st}{)}^{\ast }(C⊢\mathrm{unpack}(\mathit{st})\text{defaultable}{)}^{\ast }}{C⊢\mathsf{struct}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{default}x:[]\to [(\mathsf{ref}x)]}$$

$\mathsf{struct}\mathsf{.}\mathsf{get}\mathsf{\_}{\mathit{sx}}^{?}xy$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be a structure type $\mathsf{struct}{\mathit{fieldtype}}^{\ast }$.

• Let the field type $\mathit{mut}\mathit{storagetype}$ be ${\mathit{fieldtype}}^{\ast }[y]$.

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

• The extension $\mathit{sx}$ must be present if and only if $\mathit{storagetype}$ is a packed type.

• Then the instruction is valid with type $[(\mathsf{ref}\mathsf{null}x)]\to [t]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{struct}{\mathit{ft}}^{\ast }{\mathit{ft}}^{\ast }[y]=\mathit{mut}\mathit{st}{\mathit{sx}}^{?}=ϵ\iff \mathit{st}=\mathrm{unpack}(\mathit{st})}{C⊢\mathsf{struct}\mathsf{.}\mathsf{get}\mathsf{\_}{\mathit{sx}}^{?}xy:[(\mathsf{ref}\mathsf{null}x)]\to [\mathrm{unpack}(\mathit{st})]}$$

$\mathsf{struct}\mathsf{.}\mathsf{set}xy$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be a structure type $\mathsf{struct}{\mathit{fieldtype}}^{\ast }$.

• Let the field type $\mathit{mut}\mathit{storagetype}$ be ${\mathit{fieldtype}}^{\ast }[y]$.

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

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

• Then the instruction is valid with type $[(\mathsf{ref}\mathsf{null}x)t]\to []$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{struct}{\mathit{ft}}^{\ast }{\mathit{ft}}^{\ast }[y]=\mathsf{var}\mathit{st}}{C⊢\mathsf{struct}\mathsf{.}\mathsf{set}xy:[(\mathsf{ref}\mathsf{null}x)\mathrm{unpack}(\mathit{st})]\to []}$$

$\mathsf{array}\mathsf{.}\mathsf{new}x$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let $\mathit{fieldtype}$ be $\mathit{mut}\mathit{storagetype}$.

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathit{mut}\mathit{st})}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}x:[\mathrm{unpack}(\mathit{st})\mathsf{i}\mathsf{32}]\to [(\mathsf{ref}x)]}$$

$\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{default}x$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let $\mathit{fieldtype}$ be $\mathit{mut}\mathit{storagetype}$.

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

• The type $t$ must be defaultable.

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathit{mut}\mathit{st})C⊢\mathrm{unpack}(\mathit{st})\text{defaultable}}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}x:[\mathsf{i}\mathsf{32}]\to [(\mathsf{ref}x)]}$$

$\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{fixed}xn$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let $\mathit{fieldtype}$ be $\mathit{mut}\mathit{storagetype}$.

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

• Then the instruction is valid with type $[t^n]\to [(\mathsf{ref}x)]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathit{mut}\mathit{st})}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{fixed}xn:[\mathrm{unpack}(\mathit{st}{)}^n]\to [(\mathsf{ref}x)]}$$

$\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{elem}xy$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let $\mathit{fieldtype}$ be $\mathit{mut}\mathit{storagetype}$.

• The storage type $\mathit{storagetype}$ must be a reference type $\mathit{rt}$.

• The element segment $C.\mathsf{elems}[y]$ must exist.

• Let ${\mathit{rt}}^{\prime }$ be the reference type $C.\mathsf{elems}[y]$.

• The reference type ${\mathit{rt}}^{\prime }$ must match $\mathit{rt}$.

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathit{mut}\mathit{rt})C⊢C.\mathsf{elems}[y]\le \mathit{rt}}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{elem}xy:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to [(\mathsf{ref}x)]}$$

$\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{data}xy$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let $\mathit{fieldtype}$ be $\mathit{mut}\mathit{storagetype}$.

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

• The type $t$ must be a numeric type or a vector type.

• The data segment $C.\mathsf{datas}[y]$ must exist.

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathit{mut}\mathit{st})\mathrm{unpack}(\mathit{st})=\mathit{numtype}\vee \mathrm{unpack}(\mathit{st})=\mathit{vectype}C.\mathsf{datas}[y]=\text{ok}}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{data}xy:[\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to [(\mathsf{ref}x)]}$$

$\mathsf{array}\mathsf{.}\mathsf{get}\mathsf{\_}{\mathit{sx}}^{?}x$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let the field type $\mathit{mut}\mathit{storagetype}$ be $\mathit{fieldtype}$.

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

• The extension $\mathit{sx}$ must be present if and only if $\mathit{storagetype}$ is a packed type.

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathit{mut}\mathit{st}){\mathit{sx}}^{?}=ϵ\iff \mathit{st}=\mathrm{unpack}(\mathit{st})}{C⊢\mathsf{array}\mathsf{.}\mathsf{get}\mathsf{\_}{\mathit{sx}}^{?}x:[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}]\to [\mathrm{unpack}(\mathit{st})]}$$

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

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let the field type $\mathit{mut}\mathit{storagetype}$ be $\mathit{fieldtype}$.

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

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathsf{var}\mathit{st})}{C⊢\mathsf{array}\mathsf{.}\mathsf{set}x:[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}\mathrm{unpack}(\mathit{st})]\to []}$$

$\mathsf{array}\mathsf{.}\mathsf{len}$

• The the instruction is valid with type $[(\mathsf{ref}\mathsf{null}\mathsf{array})]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢\mathsf{array}\mathsf{.}\mathsf{len}:[(\mathsf{ref}\mathsf{null}\mathsf{array})]\to [\mathsf{i}\mathsf{32}]}$$

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

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let the field type $\mathit{mut}\mathit{storagetype}$ be $\mathit{fieldtype}$.

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

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathsf{var}\mathit{st})}{C⊢\mathsf{array}\mathsf{.}\mathsf{fill}x:[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}\mathrm{unpack}(\mathit{st})\mathsf{i}\mathsf{32}]\to []}$$

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

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}{\mathit{fieldtype}}_1$.

• Let the field type ${\mathit{mut}}_1{\mathit{storagetype}}_1$ be ${\mathit{fieldtype}}_1$.

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

• The defined type $C.\mathsf{types}[y]$ must exist.

• The expansion of $C.\mathsf{types}[y]$ must be an array type $\mathsf{array}{\mathit{fieldtype}}_2$.

• Let the field type ${\mathit{mut}}_2{\mathit{storagetype}}_2$ be ${\mathit{fieldtype}}_2$.

• The storage type ${\mathit{storagetype}}_2$ must match ${\mathit{storagetype}}_1$.

• Then the instruction is valid with type $[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}(\mathsf{ref}\mathsf{null}y)\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathsf{var}{\mathit{st}}_{\mathit{1}})\mathrm{expand}(C.\mathsf{types}[y])=\mathsf{array}(\mathit{mut}{\mathit{st}}_{\mathit{2}})C⊢{\mathit{st}}_{\mathit{2}}\le {\mathit{st}}_{\mathit{1}}}{C⊢\mathsf{array}\mathsf{.}\mathsf{copy}xy:[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}(\mathsf{ref}\mathsf{null}y)\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{array}\mathsf{.}\mathsf{init}\mathsf{\_}\mathsf{data}xy$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let the field type $\mathit{mut}\mathit{storagetype}$ be $\mathit{fieldtype}$.

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

• Let $t$ be the value type $\mathrm{unpack}(\mathit{storagetype})$.

• The value type $t$ must be a numeric type or a vector type.

• The data segment $C.\mathsf{datas}[y]$ must exist.

• Then the instruction is valid with type $[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathsf{var}\mathit{st})\mathrm{unpack}(\mathit{st})=\mathit{numtype}\vee \mathrm{unpack}(\mathit{st})=\mathit{vectype}C.\mathsf{datas}[y]=\text{ok}}{C⊢\mathsf{array}\mathsf{.}\mathsf{init}\mathsf{\_}\mathsf{data}xy:[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

$\mathsf{array}\mathsf{.}\mathsf{init}\mathsf{\_}\mathsf{elem}xy$

• The defined type $C.\mathsf{types}[x]$ must exist.

• The expansion of $C.\mathsf{types}[x]$ must be an array type $\mathsf{array}\mathit{fieldtype}$.

• Let the field type $\mathit{mut}\mathit{storagetype}$ be $\mathit{fieldtype}$.

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

• The storage type $\mathit{storagetype}$ must be a reference type $\mathit{rt}$.

• The element segment $C.\mathsf{elems}[y]$ must exist.

• Let ${\mathit{rt}}^{\prime }$ be the reference type $C.\mathsf{elems}[y]$.

• The reference type ${\mathit{rt}}^{\prime }$ must match $\mathit{rt}$.

• Then the instruction is valid with type $[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{array}(\mathsf{var}\mathit{rt})C⊢C.\mathsf{elems}[y]\le \mathit{rt}}{C⊢\mathsf{array}\mathsf{.}\mathsf{init}\mathsf{\_}\mathsf{elem}xy:[(\mathsf{ref}\mathsf{null}x)\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]\to []}$$

Scalar Reference Instructions

$\mathsf{ref}\mathsf{.}\mathsf{i}\mathsf{31}$

• The instruction is valid with type $[\mathsf{i}\mathsf{32}]\to [(\mathsf{ref}\mathsf{i}\mathsf{31})]$.

$$\frac{}{C⊢\mathsf{ref}\mathsf{.}\mathsf{i}\mathsf{31}:[\mathsf{i}\mathsf{32}]\to [(\mathsf{ref}\mathsf{i}\mathsf{31})]}$$

$\mathsf{i}\mathsf{31.}\mathsf{get}\mathsf{\_}\mathit{sx}$

• The instruction is valid with type $[(\mathsf{ref}\mathsf{null}\mathsf{i}\mathsf{31})]\to [\mathsf{i}\mathsf{32}]$.

$$\frac{}{C⊢\mathsf{i}\mathsf{31.}\mathsf{get}\mathsf{\_}\mathit{sx}:[(\mathsf{ref}\mathsf{null}\mathsf{i}\mathsf{31})]\to [\mathsf{i}\mathsf{32}]}$$

External Reference Instructions

$\mathsf{any}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{extern}$

• The instruction is valid with type $[(\mathsf{ref}{\mathsf{null}}_1^{?}\mathsf{extern})]\to [(\mathsf{ref}{\mathsf{null}}_2^{?}\mathsf{any})]$ for any ${\mathsf{null}}_1^{?}$ that equals ${\mathsf{null}}_2^{?}$.

$$\frac{{\mathsf{null}}_1^{?}={\mathsf{null}}_2^{?}}{C⊢\mathsf{any}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{extern}:[(\mathsf{ref}{\mathsf{null}}_1^{?}\mathsf{extern})]\to [(\mathsf{ref}{\mathsf{null}}_2^{?}\mathsf{any})]}$$

$\mathsf{extern}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{any}$

• The instruction is valid with type $[(\mathsf{ref}{\mathsf{null}}_1^{?}\mathsf{any})]\to [(\mathsf{ref}{\mathsf{null}}_2^{?}\mathsf{extern})]$ for any ${\mathsf{null}}_1^{?}$ that equals ${\mathsf{null}}_2^{?}$.

$$\frac{{\mathsf{null}}_1^{?}={\mathsf{null}}_2^{?}}{C⊢\mathsf{extern}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{any}:[(\mathsf{ref}{\mathsf{null}}_1^{?}\mathsf{any})]\to [(\mathsf{ref}{\mathsf{null}}_2^{?}\mathsf{extern})]}$$

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}{lll}\mathrm{unpack}(t\mathsf{x}N)& =& \mathrm{unpack}(t)\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{unpack}(\mathit{shape})$.

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

$$\frac{}{C⊢\mathit{shape}\mathsf{.}\mathsf{splat}:[\mathrm{unpack}(\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{unpack}(\mathit{shape})]$.

$$\frac{\mathit{laneidx}<\dim (\mathit{shape})}{C⊢\mathit{shape}\mathsf{.}\mathsf{extract}\mathsf{\_}\mathsf{lane}\mathsf{\_}{\mathit{sx}}^{?}\mathit{laneidx}:[\mathsf{v}\mathsf{128}]\to [\mathrm{unpack}(\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{unpack}(\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{unpack}(\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 valid value type $t$.

$$\frac{C⊢t\text{ok}}{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 result type $[t^{\ast }]$ must be valid.

  • 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 valid value type $t$ that matches some number type or vector type.

$$\frac{C⊢[t]\text{ok}}{C⊢\mathsf{select}t:[tt\mathsf{i}\mathsf{32}]\to [t]}\frac{C⊢[t]\text{ok}C⊢[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 $\mathit{init}t$ be the local type $C.\mathsf{locals}[x]$.

• The initialization status $\mathit{init}$ must be $\mathsf{set}$.

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

$$\frac{C.\mathsf{locals}[x]=\mathsf{set}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 $\mathit{init}t$ be the local type $C.\mathsf{locals}[x]$.

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

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

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

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

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

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

$$\frac{C.\mathsf{locals}[x]=\mathit{init}t}{C⊢\mathsf{local}\mathsf{.}\mathsf{tee}x:[t]{\to }_x[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_2$ must match $t_1$.

• 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{t}_{1}C.\mathsf{tables}[y]={\mathit{limits}}_2{t}_{2}C⊢t_2\le t_1}{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_2$ must match $t_1$.

• 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}{t}_{1}C.\mathsf{elems}[y]=t_{2}C⊢t_2\le t_1}{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 []}$$

Control Instructions

$\mathsf{nop}$

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

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

$\mathsf{unreachable}$

• The instruction is valid with any valid type of the form $[t_1^{\ast }]\to [t_2^{\ast }]$.

$$\frac{C⊢[t_1^{\ast }]\to [t_2^{\ast }]\text{ok}}{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 instruction 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 instruction type $[t_1^{\ast }]{\to }_{x^{\ast }}[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 instruction 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 any valid type of the form $[t_1^{\ast }{t}^{\ast }]\to [t_2^{\ast }]$.

$$\frac{C.\mathsf{labels}[l]=[t^{\ast }]C⊢[t_1^{\ast }{t}^{\ast }]\to [t_2^{\ast }]\text{ok}}{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 each label $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 value types, such that:

  • The result type $[t^{\ast }]$ matches $C.\mathsf{labels}[l_N]$.

  • For all $l_i$ in $l^{\ast }$, the result type $[t^{\ast }]$ matches $C.\mathsf{labels}[l_i]$.

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

$$\frac{(C⊢[t^{\ast }]\le C.\mathsf{labels}[l]{)}^{\ast }C⊢[t^{\ast }]\le C.\mathsf{labels}[l_N]C⊢[t_1^{\ast }{t}^{\ast }\mathsf{i}\mathsf{32}]\to [t_2^{\ast }]\text{ok}}{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.

Furthermore, the result type $[t^{\ast }]$ is also chosen non-deterministically in this rule. Although it may seem necessary to compute $[t^{\ast }]$ as the greatest lower bound of all label types in practice, a simple linear algorithm does not require this.

$\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{null}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{ref}\mathsf{null}\mathit{ht})]\to [t^{\ast }(\mathsf{ref}\mathit{ht})]$ for any valid heap type $\mathit{ht}$.

$$\frac{C.\mathsf{labels}[l]=[t^{\ast }]C⊢\mathit{ht}\text{ok}}{C⊢\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{null}l:[t^{\ast }(\mathsf{ref}\mathsf{null}\mathit{ht})]\to [t^{\ast }(\mathsf{ref}\mathit{ht})]}$$

$\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{non}\mathsf{\_}\mathsf{null}l$

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

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

• The result type $[{t^{\prime }}^{\ast }]$ must contain at least one type.

• Let the value type $t_l$ be the last element in the sequence ${t^{\prime }}^{\ast }$, and $[t^{\ast }]$ the remainder of the sequence preceding it.

• The value type $t_l$ must be a reference type of the form $\mathsf{ref}{\mathsf{null}}^{?}\mathit{ht}$.

• Then the instruction is valid with type $[t^{\ast }(\mathsf{ref}\mathsf{null}\mathit{ht})]\to [t^{\ast }]$.

$$\frac{C.\mathsf{labels}[l]=[t^{\ast }(\mathsf{ref}\mathit{ht})]}{C⊢\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{non}\mathsf{\_}\mathsf{null}l:[t^{\ast }(\mathsf{ref}\mathsf{null}\mathit{ht})]\to [t^{\ast }]}$$

$\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{cast}l{\mathit{rt}}_1{\mathit{rt}}_2$

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

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

• The type sequence $t_l^{\ast }$ must be of the form $t^{\ast }{\mathit{rt}}^{\prime }$.

• The reference type ${\mathit{rt}}_1$ must be valid.

• The reference type ${\mathit{rt}}_2$ must be valid.

• The reference type ${\mathit{rt}}_2$ must match ${\mathit{rt}}_1$.

• The reference type ${\mathit{rt}}_2$ must match ${\mathit{rt}}^{\prime }$.

• Let ${\mathit{rt}}_1^{\prime }$ be the type difference between ${\mathit{rt}}_1$ and ${\mathit{rt}}_2$.

• Then the instruction is valid with type $[t^{\ast }{\mathit{rt}}_1]\to [t^{\ast }{\mathit{rt}}_1^{\prime }]$.

$$\frac{C.\mathsf{labels}[l]=[t^{\ast }\mathit{rt}]C⊢{\mathit{rt}}_1\text{ok}C⊢{\mathit{rt}}_2\text{ok}C⊢{\mathit{rt}}_2\le {\mathit{rt}}_{1}C⊢{\mathit{rt}}_2\le \mathit{rt}}{C⊢\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{cast}l{\mathit{rt}}_1{\mathit{rt}}_2:[t^{\ast }{\mathit{rt}}_1]\to [t^{\ast }{\mathit{rt}}_1\setminus {\mathit{rt}}_2]}$$

$\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{cast}\mathsf{\_}\mathsf{fail}l{\mathit{rt}}_1{\mathit{rt}}_2$

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

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

• The type sequence $t_l^{\ast }$ must be of the form $t^{\ast }{\mathit{rt}}^{\prime }$.

• The reference type ${\mathit{rt}}_1$ must be valid.

• The reference type ${\mathit{rt}}_2$ must be valid.

• The reference type ${\mathit{rt}}_2$ must match ${\mathit{rt}}_1$.

• Let ${\mathit{rt}}_1^{\prime }$ be the type difference between ${\mathit{rt}}_1$ and ${\mathit{rt}}_2$.

• The reference type ${\mathit{rt}}_1^{\prime }$ must match ${\mathit{rt}}^{\prime }$.

• Then the instruction is valid with type $[t^{\ast }{\mathit{rt}}_1]\to [t^{\ast }{\mathit{rt}}_2]$.

$$\frac{C.\mathsf{labels}[l]=[t^{\ast }\mathit{rt}]C⊢{\mathit{rt}}_1\text{ok}C⊢{\mathit{rt}}_2\text{ok}C⊢{\mathit{rt}}_2\le {\mathit{rt}}_{1}C⊢{\mathit{rt}}_1\setminus {\mathit{rt}}_2\le \mathit{rt}}{C⊢\mathsf{br}\mathsf{\_}\mathsf{on}\mathsf{\_}\mathsf{cast}\mathsf{\_}\mathsf{fail}l{\mathit{rt}}_1{\mathit{rt}}_2:[t^{\ast }{\mathit{rt}}_1]\to [t^{\ast }{\mathit{rt}}_2]}$$

$\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 any valid type of the form $[t_1^{\ast }]\to [t_2^{\ast }]$.

$$\frac{C.\mathsf{return}=[t^{\ast }]C⊢[t_1^{\ast }{t}^{\ast }]\to [t_2^{\ast }]\text{ok}}{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.

• The expansion of $C.\mathsf{funcs}[x]$ must be a function type $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$.

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

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

$\mathsf{call}\mathsf{\_}\mathsf{ref}x$

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

• The expansion of $C.\mathsf{funcs}[x]$ must be a function type $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$.

• Then the instruction is valid with type $[t_1^{\ast }(\mathsf{ref}\mathsf{null}x)]\to [t_2^{\ast }]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]}{C⊢\mathsf{call}\mathsf{\_}\mathsf{ref}x:[t_1^{\ast }(\mathsf{ref}\mathsf{null}x)]\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 match type $\mathsf{ref}\mathsf{null}\mathsf{func}$.

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

• The expansion of $C.\mathsf{types}[y]$ must be a function type $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$.

• 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}tC⊢t\le \mathsf{ref}\mathsf{null}\mathsf{func}\mathrm{expand}(C.\mathsf{types}[y])=\mathsf{func}[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 }]}$$

$\mathsf{return}\mathsf{\_}\mathsf{call}x$

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

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

• The expansion of $C.\mathsf{funcs}[x]$ must be a function type $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$.

• The result type $[t_2^{\ast }]$ must match $C.\mathsf{return}$.

• Then the instruction is valid with any valid type $[t_3^{\ast }{t}_1^{\ast }]\to [t_4^{\ast }]$.

$$\frac{\mathrm{expand}(C.\mathsf{funcs}[x])=\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]C⊢[t_2^{\ast }]\le C.\mathsf{return}}{C⊢\mathsf{return}\mathsf{\_}\mathsf{call}x:[t_3^{\ast }{t}_1^{\ast }]\to [t_4^{\ast }]}$$

Note

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

$\mathsf{return}\mathsf{\_}\mathsf{call}\mathsf{\_}\mathsf{ref}x$

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

• The expansion of $C.\mathsf{types}[x]$ must be a function type $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$.

• The result type $[t_2^{\ast }]$ must match $C.\mathsf{return}$.

• Then the instruction is valid with any valid type $[t_3^{\ast }{t}_1^{\ast }(\mathsf{ref}\mathsf{null}x)]\to [t_4^{\ast }]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]C⊢[t_2^{\ast }]\le C.\mathsf{return}}{C⊢\mathsf{call}\mathsf{\_}\mathsf{ref}x:[t_3^{\ast }{t}_1^{\ast }(\mathsf{ref}\mathsf{null}x)]\to [t_4^{\ast }]}$$

Note

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

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

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

• 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 match type $\mathsf{ref}\mathsf{null}\mathsf{func}$.

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

• The expansion of $C.\mathsf{types}[y]$ must be a function type $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$.

• The result type $[t_2^{\ast }]$ must match $C.\mathsf{return}$.

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

$$\frac{C.\mathsf{tables}[x]=\mathit{limits}tC⊢t\le \mathsf{ref}\mathsf{null}\mathsf{func}\mathrm{expand}(C.\mathsf{types}[y])=\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]C⊢[t_2^{\ast }]\le C.\mathsf{return}}{C⊢\mathsf{return}\mathsf{\_}\mathsf{call}\mathsf{\_}\mathsf{indirect}xy:[t_3^{\ast }{t}_1^{\ast }\mathsf{i}\mathsf{32}]\to [t_4^{\ast }]}$$

Note

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

Instruction Sequences

Typing of instruction sequences is defined recursively.

Empty Instruction Sequence: $ϵ$

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

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

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

• The instruction $\mathit{instr}$ must be valid with some type $[t_1^{\ast }]{\to }_{x_1^{\ast }}[t_2^{\ast }]$.

• Let $C^{\prime }$ be the same context as $C$, but with:

  • $\mathsf{locals}$ the same as in C, except that for every local index $x$ in $x_1^{\ast }$, the local type $\mathsf{locals}[x]$ has been updated to initialization status $\mathsf{set}$.

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

• Then the combined instruction sequence is valid with type $[t_1^{\ast }]{\to }_{x_1^{\ast }{x}_2^{\ast }}[t_3^{\ast }]$.

$$\begin{array}{r}\frac{\begin{array}{ll}C⊢\mathit{instr}:[t_1^{\ast }]{\to }_{x_1^{\ast }}[t_2^{\ast }]& (C.\mathsf{locals}[x_1]=\mathit{init}t{)}^{\ast }\\ C^{\prime }⊢{{\mathit{instr}}^{\prime }}^{\ast }:[t_2^{\ast }]{\to }_{x_2^{\ast }}[t_3^{\ast }]& C^{\prime }=C(\text{with}C.\mathsf{locals}[x_1]=\mathsf{set}t{)}^{\ast }\end{array}}{C⊢\mathit{instr}{{\mathit{instr}}^{\prime }}^{\ast }:[t_1^{\ast }]{\to }_{x_1^{\ast }{x}_2^{\ast }}[t_2^{\ast }{t}_3^{\ast }]}\end{array}$$

Subsumption for ${\mathit{instr}}^{\ast }$

• The instruction sequence ${\mathit{instr}}^{\ast }$ must be valid with some type $\mathit{instrtype}$.

• The instruction type ${\mathit{instrtype}}^{\prime }$: must be a valid

• The instruction type $\mathit{instrtype}$ must match the type ${\mathit{instrtype}}^{\prime }$.

• Then the instruction sequence ${\mathit{instr}}^{\ast }$ is also valid with type ${\mathit{instrtype}}^{\prime }$.

$$\frac{\begin{array}{c}C⊢\mathit{instr}:\mathit{instrtype}C⊢{\mathit{instrtype}}^{\prime }\text{ok}C⊢\mathit{instrtype}\le {\mathit{instrtype}}^{\prime }\end{array}}{C⊢{\mathit{instr}}^{\ast }:{\mathit{instrtype}}^{\prime }}$$

Note

In combination with the previous rule, subsumption allows to compose instructions whose types would not directly fit otherwise. For example, consider the instruction sequence

$$(\mathsf{i}\mathsf{32}.\mathsf{const}1)(\mathsf{i}\mathsf{32}.\mathsf{const}1)\mathsf{i}\mathsf{32}.\mathsf{add}$$

To type this sequence, its subsequence $(\mathsf{i}\mathsf{32}.\mathsf{const}1)\mathsf{i}\mathsf{32}.\mathsf{add}$ needs to be valid with an intermediate type. But the direct type of $(\mathsf{i}\mathsf{32}.\mathsf{const}1)$ is $[]\to [\mathsf{i}\mathsf{32}]$, not matching the two inputs expected by $\mathsf{i}\mathsf{32}.\mathsf{add}$. The subsumption rule allows to weaken the type of $(\mathsf{i}\mathsf{32}.\mathsf{const}1)$ to the supertype $[\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}\mathsf{i}\mathsf{32}]$, such that it can be composed with $\mathsf{i}\mathsf{32}.\mathsf{add}$ and yields the intermediate type $[\mathsf{i}\mathsf{32}]\to [\mathsf{i}\mathsf{32}]$ for the subsequence. That can in turn be composed with the first constant.

Furthermore, subsumption allows to drop init variables $x^{\ast }$ from the instruction type in a context where they are not needed, for example, at the end of the body of a block.

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 type $[]\to [t^{\ast }]$.

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

$$\frac{C⊢{\mathit{instr}}^{\ast }:[]\to [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{i}\mathsf{31}$,

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

  • or of the form $\mathsf{struct}\mathsf{.}\mathsf{new}x$,

  • or of the form $\mathsf{struct}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{default}x$,

  • or of the form $\mathsf{array}\mathsf{.}\mathsf{new}x$,

  • or of the form $\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{default}x$,

  • or of the form $\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{fixed}x$,

  • or of the form $\mathsf{any}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{extern}$,

  • or of the form $\mathsf{extern}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{any}$,

  • 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{globals}[x]=\mathsf{const}t}{C⊢\mathsf{global}\mathsf{.}\mathsf{get}x\text{const}}$$

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

$$\frac{}{C⊢\mathsf{struct}\mathsf{.}\mathsf{new}x\text{const}}\frac{}{C⊢\mathsf{struct}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{default}x\text{const}}$$

$$\frac{}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}x\text{const}}\frac{}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{default}x\text{const}}\frac{}{C⊢\mathsf{array}\mathsf{.}\mathsf{new}\mathsf{\_}\mathsf{fixed}x\text{const}}$$

$$\frac{}{C⊢\mathsf{any}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{extern}\text{const}}\frac{}{C⊢\mathsf{extern}\mathsf{.}\mathsf{convert}\mathsf{\_}\mathsf{any}\text{const}}$$

Note

Currently, constant expressions occurring in globals are further constrained in that contained $\mathsf{global}\mathsf{.}\mathsf{get}$ instructions are only allowed to refer to imported or previously defined globals. Constant expressions occurring in tables may only have $\mathsf{global}\mathsf{.}\mathsf{get}$ instructions that 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.