Types

Simple types, such as number types are universally valid. However, restrictions apply to most other types, such as reference types, function types, as well as the limits of table types and memory types, which must be checked during validation.

Moreover, block types are converted to plain function types for ease of processing.

Number Types

Number types are always valid.

$$\frac{}{C⊢\mathit{numtype}\text{ok}}$$

Vector Types

Vector types are always valid.

$$\frac{}{C⊢\mathit{vectype}\text{ok}}$$

Heap Types

Concrete heap types are only valid when the type index is, while abstract ones are vacuously valid.

$\mathit{absheaptype}$

• The heap type is valid.

$$\frac{}{C⊢\mathit{absheaptype}\text{ok}}$$

$\mathit{typeidx}$

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

• Then the heap type is valid.

$$\frac{C.\mathsf{types}[\mathit{typeidx}]=\mathit{deftype}}{C⊢\mathit{typeidx}\text{ok}}$$

Reference Types

Reference types are valid when the referenced heap type is.

$\mathsf{ref}{\mathsf{null}}^{?}\mathit{heaptype}$

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

• Then the reference type is valid.

$$\frac{C⊢\mathit{heaptype}\text{ok}}{C⊢\mathsf{ref}{\mathsf{null}}^{?}\mathit{heaptype}\text{ok}}$$

Value Types

Valid value types are either valid number types, valid vector types, or valid reference types.

Block Types

Block types may be expressed in one of two forms, both of which are converted to instruction types by the following rules.

$\mathit{typeidx}$

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

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

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

$$\frac{\mathrm{expand}(C.\mathsf{types}[\mathit{typeidx}])=\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]}{C⊢\mathit{typeidx}:[t_1^{\ast }]\to [t_2^{\ast }]}$$

$[{\mathit{valtype}}^{?}]$

• The value type $\mathit{valtype}$ must either be absent, or valid.

• Then the block type is valid as instruction type $[]\to [{\mathit{valtype}}^{?}]$.

$$\frac{(C⊢\mathit{valtype}\text{ok}{)}^{?}}{C⊢[{\mathit{valtype}}^{?}]:[]\to [{\mathit{valtype}}^{?}]}$$

Result Types

$[t^{\ast }]$

• Each value type $t_i$ in the type sequence $t^{\ast }$ must be valid.

• Then the result type is valid.

$$\frac{(C⊢t\text{ok}{)}^{\ast }}{C⊢[t^{\ast }]\text{ok}}$$

Instruction Types

$[t_1^{\ast }]{\to }_{x^{\ast }}[t_2^{\ast }]$

• The result type $[t_1^{\ast }]$ must be valid.

• The result type $[t_2^{\ast }]$ must be valid.

• Each local index $x_i$ in $x^{\ast }$ must be defined in the context.

• Then the instruction type is valid.

$$\frac{C⊢[t_1^{\ast }]\text{ok}C⊢[t_2^{\ast }]\text{ok}(C.\mathsf{locals}[x]=\mathit{localtype}{)}^{\ast }}{C⊢[t_1^{\ast }]{\to }_{x^{\ast }}[t_2^{\ast }]\text{ok}}$$

Function Types

$[t_1^{\ast }]\to [t_2^{\ast }]$

• The result type $[t_1^{\ast }]$ must be valid.

• The result type $[t_2^{\ast }]$ must be valid.

• Then the function type is valid.

$$\frac{C⊢[t_1^{\ast }]\text{ok}C⊢[t_2^{\ast }]\text{ok}}{C⊢[t_1^{\ast }]\to [t_2^{\ast }]\text{ok}}$$

Composite Types

$\mathsf{func}\mathit{functype}$

• The function type $\mathit{functype}$ must be valid.

• Then the composite type is valid.

$$\frac{C⊢\mathit{functype}\text{ok}}{C⊢\mathsf{func}\mathit{functype}\text{ok}}$$

$\mathsf{struct}{\mathit{fieldtype}}^{\ast }$

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

  • The field type ${\mathit{fieldtype}}_i$ must be valid.

• Then the composite type is valid.

$$\frac{(C⊢\mathit{ft}\text{ok}{)}^{\ast }}{C⊢\mathsf{struct}{\mathit{ft}}^{\ast }\text{ok}}$$

$\mathsf{array}\mathit{fieldtype}$

• The field type $\mathit{fieldtype}$ must be valid.

• Then the composite type is valid.

$$\frac{C⊢\mathit{ft}\text{ok}}{C⊢\mathsf{array}\mathit{ft}\text{ok}}$$

Field Types

$\mathit{mut}\mathit{storagetype}$

• The storage type $\mathit{storagetype}$ must be valid.

• Then the field type is valid.

$$\frac{C⊢\mathit{st}\text{ok}}{C⊢\mathit{mut}\mathit{st}\text{ok}}$$

$\mathit{packedtype}$

• The packed type is valid.

$$\frac{}{C⊢\mathit{packedtype}\text{ok}}$$

Recursive Types

Recursive types are validated for a specific type index that denotes the index of the type defined by the recursive group.

$\mathsf{rec}{\mathit{subtype}}^{\ast }$

• Either the sequence ${\mathit{subtype}}^{\ast }$ is empty.

• Or:

  • The first sub type of the sequence ${\mathit{subtype}}^{\ast }$ must be valid for the type index $x$.

  • The remaining sequence ${\mathit{subtype}}^{\ast }$ must be valid for the type index $x+1$.

• Then the recursive type is valid for the type index $x$.

$$\frac{}{C⊢\mathsf{rec}ϵ\text{ok}(x)}\frac{C⊢\mathit{subtype}\text{ok}(x)C⊢\mathsf{rec}{{\mathit{subtype}}^{\prime }}^{\ast }\text{ok}(x+1)}{C⊢\mathsf{rec}\mathit{subtype}{{\mathit{subtype}}^{\prime }}^{\ast }\text{ok}(x)}$$

$\mathsf{sub}{\mathsf{final}}^{?}{y}^{\ast }\mathit{comptype}$

• The composite type $\mathit{comptype}$ must be valid.

• The sequence $y^{\ast }$ may be no longer than $1$.

• For every type index $y_i$ in $y^{\ast }$:

  • The type index $y_i$ must be smaller than $x$.

  • The type index $y_i$ must exist in the context $C$.

  • Let ${\mathit{subtype}}_i$ be the unrolling of the defined type $C.\mathsf{types}[y_i]$.

  • The sub type ${\mathit{subtype}}_i$ must not contain $\mathsf{final}$.

  • Let ${\mathit{comptype}}_i^{\prime }$ be the composite type in ${\mathit{subtype}}_i$.

  • The composite type $\mathit{comptype}$ must match ${\mathit{comptype}}_i^{\prime }$.

• Then the sub type is valid for the type index $x$.

$$\begin{array}{r}\frac{\begin{array}{c}|y^{\ast }|\le 1(y<x{)}^{\ast }(\mathrm{unroll}(C.\mathsf{types}[y])=\mathsf{sub}{y^{\prime }}^{\ast }{\mathit{comptype}}^{\prime }{)}^{\ast }\\ C⊢\mathit{comptype}\text{ok}(C⊢\mathit{comptype}\le {\mathit{comptype}}^{\prime }{)}^{\ast }\end{array}}{C⊢\mathsf{sub}{\mathsf{final}}^{?}{y}^{\ast }\mathit{comptype}\text{ok}(x)}\end{array}$$

Note

The side condition on the index ensures that a declared supertype is a previously defined types, preventing cyclic subtype hierarchies.

Future versions of WebAssembly may allow more than one supertype.

Defined Types

$\mathit{rectype}.i$

• The recursive type $\mathit{rectype}$ must be valid for some type index $x$.

• Let $\mathsf{rec}{\mathit{subtype}}^{\ast }$ be the defined type $\mathit{rectype}$.

• The number $i$ must be smaller than the length of the sequence ${\mathit{subtype}}^{\ast }$ of sub types.

• Then the defined type is valid.

$$\frac{C⊢\mathit{rectype}\text{ok}(x)\mathit{rectype}=\mathsf{rec}{\mathit{subtype}}^{n}i<n}{C⊢\mathit{rectype}.i\text{ok}}$$

Limits

Limits must have meaningful bounds that are within a given range.

$\{\mathsf{min}n,\mathsf{max}{m}^{?}\}$

• The value of $n$ must not be larger than $k$.

• If the maximum $m^{?}$ is not empty, then:

  • Its value must not be larger than $k$.

  • Its value must not be smaller than $n$.

• Then the limit is valid within range $k$.

$$\frac{n\le k(m\le k{)}^{?}(n\le m{)}^{?}}{C⊢\{\mathsf{min}n,\mathsf{max}{m}^{?}\}:k}$$

Table Types

$\mathit{limits}\mathit{reftype}$

• The limits $\mathit{limits}$ must be valid within range $2^{32}-1$.

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

• Then the table type is valid.

$$\frac{C⊢\mathit{limits}:2^{32}-1C⊢\mathit{reftype}\text{ok}}{C⊢\mathit{limits}\mathit{reftype}\text{ok}}$$

Memory Types

$\mathit{limits}$

• The limits $\mathit{limits}$ must be valid within range $2^{16}$.

• Then the memory type is valid.

$$\frac{C⊢\mathit{limits}:2^{16}}{C⊢\mathit{limits}\text{ok}}$$

Global Types

$\mathit{mut}\mathit{valtype}$

• The value type $\mathit{valtype}$ must be valid.

• Then the global type is valid.

$$\frac{C⊢\mathit{valtype}\text{ok}}{C⊢\mathit{mut}\mathit{valtype}\text{ok}}$$

External Types

$\mathsf{func}\mathit{deftype}$

• The defined type $\mathit{deftype}$ must be valid.

• The defined type $\mathit{deftype}$ must be a function type.

• Then the external type is valid.

$$\frac{C⊢\mathit{deftype}\text{ok}\mathrm{expand}(\mathit{deftype})=\mathsf{func}\mathit{functype}}{C⊢\mathsf{func}\mathit{deftype}}$$

$\mathsf{table}\mathit{tabletype}$

• The table type $\mathit{tabletype}$ must be valid.

• Then the external type is valid.

$$\frac{C⊢\mathit{tabletype}\text{ok}}{C⊢\mathsf{table}\mathit{tabletype}\text{ok}}$$

$\mathsf{mem}\mathit{memtype}$

• The memory type $\mathit{memtype}$ must be valid.

• Then the external type is valid.

$$\frac{C⊢\mathit{memtype}\text{ok}}{C⊢\mathsf{mem}\mathit{memtype}\text{ok}}$$

$\mathsf{global}\mathit{globaltype}$

• The global type $\mathit{globaltype}$ must be valid.

• Then the external type is valid.

$$\frac{C⊢\mathit{globaltype}\text{ok}}{C⊢\mathsf{global}\mathit{globaltype}\text{ok}}$$

Defaultable Types

A type is defaultable if it has a default value for initialization.

Value Types

• A defaultable value type $t$ must be:

  • either a number type,

  • or a vector type,

  • or a nullable reference type.

$$\frac{}{C⊢\mathit{numtype}\text{defaultable}}$$

$$\frac{}{C⊢\mathit{vectype}\text{defaultable}}$$

$$\frac{}{C⊢(\mathsf{ref}\mathsf{null}\mathit{heaptype})\text{defaultable}}$$