Modules

Modules are valid when all the components they contain are valid. Furthermore, most definitions are themselves classified with a suitable type.

Types

The sequence of types defined in a module is validated incrementally, yielding a suitable context.

${\mathit{type}}^{\ast }$

• If the sequence is empty, then:

  • The context $C$ must be empty.

  • Then the type sequence is valid.

• Otherwise:

  • Let the recursive type $\mathit{rectype}$ be the last element in the sequence.

  • The sequence without $\mathit{rectype}$ must be valid for some context $C^{\prime }$.

  • Let the type index $x$ be the length of $C^{\prime }.\mathsf{types}$, i.e., the first type index free in $C^{\prime }$.

  • Let the sequence of defined types ${\mathit{deftype}}^{\ast }$ be the result ${\mathrm{roll}}_x^{\ast }(\mathit{rectype})$ of rolling up into its sequence of defined types.

  • The recursive type $\mathit{rectype}$ must be valid under the context $C$ for type index $x$.

  • The current context $C$ be the same as $C^{\prime }$, but with ${\mathit{deftype}}^{\ast }$ appended to $\mathsf{types}$.

  • Then the type sequence is valid.

$$\frac{}{\{\}⊢ϵ\text{ok}}$$

$$\frac{C^{\prime }⊢{\mathit{type}}^{\ast }\text{ok}C=C^{\prime }\text{with}\mathsf{types}=C^{\prime }.\mathsf{types}{\mathrm{roll}}_{|C^{\prime }.\mathsf{types}|}^{\ast }(\mathit{rectype})C⊢\mathit{rectype}\text{ok}(|C^{\prime }.\mathsf{types}|)}{C⊢{\mathit{type}}^{\ast }\mathit{rectype}\text{ok}}$$

Note

Despite the appearance, the context $C$ is effectively an _output_ of this judgement.

Functions

Functions $\mathit{func}$ are classified by defined types that expand to function types of the form $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$.

$\{\mathsf{type}x,\mathsf{locals}{t}^{\ast },\mathsf{body}\mathit{expr}\}$

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

• Let $\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }]$ be the expansion of the defined type $C.\mathsf{types}[x]$.

• For each local declared by a value type $t$ in $t^{\ast }$:

  • The local for type $t$ must be valid with local type ${\mathit{localtype}}_i$.

• Let ${\mathit{localtype}}^{\ast }$ be the concatenation of all ${\mathit{localtype}}_i$.

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

  • $\mathsf{locals}$ set to the sequence of value types $(\mathsf{set}{t}_1{)}^{\ast }{\mathit{localtype}}^{\ast }$, concatenating parameters and locals,

  • $\mathsf{labels}$ set to the singular sequence containing only result type $[t_2^{\ast }]$.

  • $\mathsf{return}$ set to the result type $[t_2^{\ast }]$.

• Under the context $C^{\prime }$, the expression $\mathit{expr}$ must be valid with type $[t_2^{\ast }]$.

• Then the function definition is valid with type $C.\mathsf{types}[x]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{func}[t_1^{\ast }]\to [t_2^{\ast }](C⊢\{\mathsf{type}t\}:\mathit{init}t{)}^{\ast }C,\mathsf{locals}(\mathsf{set}{t}_1{)}^{\ast }(\mathit{init}t{)}^{\ast },\mathsf{labels}[t_2^{\ast }],\mathsf{return}[t_2^{\ast }]⊢\mathit{expr}:[t_2^{\ast }]}{C⊢\{\mathsf{type}x,\mathsf{locals}\{\mathsf{type}t{\}}^{\ast },\mathsf{body}\mathit{expr}\}:C.\mathsf{types}[x]}$$

Locals

Locals are classified with local types.

$\{\mathsf{type}\mathit{valtype}\}$

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

• If $\mathit{valtype}$ is defaultable, then:

  • The local is valid with local type $\mathsf{set}\mathit{valtype}$.

• Else:

  • The local is valid with local type $\mathsf{unset}\mathit{valtype}$.

$$\frac{C⊢t\text{ok}C⊢t\text{defaultable}}{C⊢\{\mathsf{type}t\}:\mathsf{set}t}$$

$$\frac{C⊢t\text{ok}}{C⊢\{\mathsf{type}t\}:\mathsf{unset}t}$$

Note

For cases where both rules are applicable, the former yields the more permissable type.

Tables

Tables $\mathit{table}$ are classified by table types.

$\{\mathsf{type}\mathit{tabletype},\mathsf{init}\mathit{expr}\}$

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

• Let $t$ be the element reference type of $\mathit{tabletype}$.

• The expression $\mathit{expr}$ must be valid with result type $[t]$.

• The expression $\mathit{expr}$ must be constant.

• Then the table definition is valid with type $\mathit{tabletype}$.

$$\frac{C⊢\mathit{tabletype}\text{ok}\mathit{tabletype}=\mathit{limits}tC⊢\mathit{expr}:[t]C⊢\mathit{expr}\text{const}}{C⊢\{\mathsf{type}\mathit{tabletype},\mathsf{init}\mathit{expr}\}:\mathit{tabletype}}$$

Memories

Memories $\mathit{mem}$ are classified by memory types.

$\{\mathsf{type}\mathit{memtype}\}$

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

• Then the memory definition is valid with type $\mathit{memtype}$.

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

Globals

Globals $\mathit{global}$ are classified by global types of the form $\mathit{mut}t$.

Sequences of globals are handled incrementally, such that each definition has access to previous definitions.

$\{\mathsf{type}\mathit{mut}t,\mathsf{init}\mathit{expr}\}$

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

• The expression $\mathit{expr}$ must be valid with result type $[t]$.

• The expression $\mathit{expr}$ must be constant.

• Then the global definition is valid with type $\mathit{mut}t$.

$$\frac{C⊢\mathit{mut}t\text{ok}C⊢\mathit{expr}:[t]C⊢\mathit{expr}\text{const}}{C⊢\{\mathsf{type}\mathit{mut}t,\mathsf{init}\mathit{expr}\}:\mathit{mut}t}$$

${\mathit{global}}^{\ast }$

• If the sequence is empty, then it is valid with the empty sequence of global types.

• Else:

  • The first global definition must be valid with some type global type ${\mathit{gt}}_1$.

  • Let $C^{\prime }$ be the same context as $C$, but with the global type ${\mathit{gt}}_1$ apppended to the $\mathsf{globals}$ vector.

  • Under context $C^{\prime }$, the remainder of the sequence must be valid with some sequence ${\mathit{gt}}^{\ast }$ of global types.

  • Then the sequence is valid with the sequence of global types consisting of ${\mathit{gt}}_1$ prepended to ${\mathit{gt}}^{\ast }$.

$$\begin{array}{r}\\ \frac{}{C⊢ϵ:ϵ}\frac{C⊢{\mathit{global}}_1:{\mathit{gt}}_{1}C\oplus \{\mathsf{globals}{\mathit{gt}}_1\}⊢{\mathit{global}}^{\ast }:{\mathit{gt}}^{\ast }}{C⊢{\mathit{global}}_1{\mathit{global}}^{\ast }:{\mathit{gt}}_1{\mathit{gt}}^{\ast }}\end{array}$$

Element Segments

Element segments $\mathit{elem}$ are classified by the reference type of their elements.

$\{\mathsf{type}t,\mathsf{init}{e}^{\ast },\mathsf{mode}\mathit{elemmode}\}$

• The reference type $t$ must be valid.

• For each $e_i$ in $e^{\ast }$,

  • The expression $e_i$ must be valid with some result type $[t]$.

  • The expression $e_i$ must be constant.

• The element mode $\mathit{elemmode}$ must be valid with some reference type $t^{\prime }$.

• The reference type $t$ must match the reference type $t^{\prime }$.

• Then the element segment is valid with reference type $t$.

$$\frac{C⊢t\text{ok}(C⊢e:[t]{)}^{\ast }(C⊢e\text{const}{)}^{\ast }C⊢\mathit{elemmode}:t^{\prime }C⊢t\le t^{\prime }}{C⊢\{\mathsf{type}t,\mathsf{init}{e}^{\ast },\mathsf{mode}\mathit{elemmode}\}:t}$$

$\mathsf{passive}$

• The element mode is valid with any valid reference type.

$$\frac{C⊢\mathit{reftype}\text{ok}}{C⊢\mathsf{passive}:\mathit{reftype}}$$

$\mathsf{active}\{\mathsf{table}x,\mathsf{offset}\mathit{expr}\}$

• 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 expression $\mathit{expr}$ must be valid with result type $[\mathsf{i}\mathsf{32}]$.

• The expression $\mathit{expr}$ must be constant.

• Then the element mode is valid with reference type $t$.

$$\begin{array}{r}\frac{\begin{array}{c}C.\mathsf{tables}[x]=\mathit{limits}t\\ C⊢\mathit{expr}:[\mathsf{i}\mathsf{32}]C⊢\mathit{expr}\text{const}\end{array}}{C⊢\mathsf{active}\{\mathsf{table}x,\mathsf{offset}\mathit{expr}\}:t}\end{array}$$

$\mathsf{declarative}$

• The element mode is valid with any valid reference type.

$$\frac{C⊢\mathit{reftype}\text{ok}}{C⊢\mathsf{declarative}:\mathit{reftype}}$$

Data Segments

Data segments $\mathit{data}$ are not classified by any type but merely checked for well-formedness.

$\{\mathsf{init}{b}^{\ast },\mathsf{mode}\mathit{datamode}\}$

• The data mode $\mathit{datamode}$ must be valid.

• Then the data segment is valid.

$$\frac{C⊢\mathit{datamode}\text{ok}}{C⊢\{\mathsf{init}{b}^{\ast },\mathsf{mode}\mathit{datamode}\}\text{ok}}$$

$\mathsf{passive}$

• The data mode is valid.

$$\frac{}{C⊢\mathsf{passive}\text{ok}}$$

$\mathsf{active}\{\mathsf{memory}x,\mathsf{offset}\mathit{expr}\}$

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

• The expression $\mathit{expr}$ must be valid with result type $[\mathsf{i}\mathsf{32}]$.

• The expression $\mathit{expr}$ must be constant.

• Then the data mode is valid.

$$\frac{C.\mathsf{mems}[x]=\mathit{limits}C⊢\mathit{expr}:[\mathsf{i}\mathsf{32}]C⊢\mathit{expr}\text{const}}{C⊢\mathsf{active}\{\mathsf{memory}x,\mathsf{offset}\mathit{expr}\}\text{ok}}$$

Start Function

Start function declarations $\mathit{start}$ are not classified by any type.

$\{\mathsf{func}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}[]\to []$.

• Then the start function is valid.

$$\frac{\mathrm{expand}(C.\mathsf{funcs}[x])=\mathsf{func}[]\to []}{C⊢\{\mathsf{func}x\}\text{ok}}$$

Exports

Exports $\mathit{export}$ and export descriptions $\mathit{exportdesc}$ are classified by their external type.

$\{\mathsf{name}\mathit{name},\mathsf{desc}\mathit{exportdesc}\}$

• The export description $\mathit{exportdesc}$ must be valid with external type $\mathit{externtype}$.

• Then the export is valid with external type $\mathit{externtype}$.

$$\frac{C⊢\mathit{exportdesc}:\mathit{externtype}}{C⊢\{\mathsf{name}\mathit{name},\mathsf{desc}\mathit{exportdesc}\}:\mathit{externtype}}$$

$\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]$.

• Then the export description is valid with external type $\mathsf{func}\mathit{dt}$.

$$\frac{C.\mathsf{funcs}[x]=\mathit{dt}}{C⊢\mathsf{func}x:\mathsf{func}\mathit{dt}}$$

$\mathsf{table}x$

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

• Then the export description is valid with external type $\mathsf{table}C.\mathsf{tables}[x]$.

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

$\mathsf{mem}x$

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

• Then the export description is valid with external type $\mathsf{mem}C.\mathsf{mems}[x]$.

$$\frac{C.\mathsf{mems}[x]=\mathit{memtype}}{C⊢\mathsf{mem}x:\mathsf{mem}\mathit{memtype}}$$

$\mathsf{global}x$

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

• Then the export description is valid with external type $\mathsf{global}C.\mathsf{globals}[x]$.

$$\frac{C.\mathsf{globals}[x]=\mathit{globaltype}}{C⊢\mathsf{global}x:\mathsf{global}\mathit{globaltype}}$$

Imports

Imports $\mathit{import}$ and import descriptions $\mathit{importdesc}$ are classified by external types.

$\{\mathsf{module}{\mathit{name}}_1,\mathsf{name}{\mathit{name}}_2,\mathsf{desc}\mathit{importdesc}\}$

• The import description $\mathit{importdesc}$ must be valid with type $\mathit{externtype}$.

• Then the import is valid with type $\mathit{externtype}$.

$$\frac{C⊢\mathit{importdesc}:\mathit{externtype}}{C⊢\{\mathsf{module}{\mathit{name}}_1,\mathsf{name}{\mathit{name}}_2,\mathsf{desc}\mathit{importdesc}\}:\mathit{externtype}}$$

$\mathsf{func}x$

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

• Then the import description is valid with type $\mathsf{func}C.\mathsf{types}[x]$.

$$\frac{\mathrm{expand}(C.\mathsf{types}[x])=\mathsf{func}\mathit{functype}}{C⊢\mathsf{func}x:\mathsf{func}C.\mathsf{types}[x]}$$

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

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

• Then the import description is valid with type $\mathsf{table}\mathit{tabletype}$.

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

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

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

• Then the import description is valid with type $\mathsf{mem}\mathit{memtype}$.

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

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

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

• Then the import description is valid with type $\mathsf{global}\mathit{globaltype}$.

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

Modules

Modules are classified by their mapping from the external types of their imports to those of their exports.

A module is entirely closed, that is, its components can only refer to definitions that appear in the module itself. Consequently, no initial context is required. Instead, the context $C$ for validation of the module’s content is constructed from the definitions in the module.

The external types classifying a module may contain free type indices that refer to types defined within the module.

• Let $\mathit{module}$ be the module to validate.

• The types $\mathit{module}.\mathsf{types}$ must be valid yielding a context $C_0$.

• Let $C$ be a context where:

  • $C.\mathsf{types}$ is $C_0.\mathsf{types}$,

  • $C.\mathsf{funcs}$ is $\mathrm{funcs}({\mathit{it}}^{\ast })$ concatenated with ${\mathit{dt}}^{\ast }$, with the import’s external types ${\mathit{it}}^{\ast }$ and the internal defined types ${\mathit{dt}}^{\ast }$ as determined below,

  • $C.\mathsf{tables}$ is $\mathrm{tables}({\mathit{it}}^{\ast })$ concatenated with ${\mathit{tt}}^{\ast }$, with the import’s external types ${\mathit{it}}^{\ast }$ and the internal table types ${\mathit{tt}}^{\ast }$ as determined below,

  • $C.\mathsf{mems}$ is $\mathrm{mems}({\mathit{it}}^{\ast })$ concatenated with ${\mathit{mt}}^{\ast }$, with the import’s external types ${\mathit{it}}^{\ast }$ and the internal memory types ${\mathit{mt}}^{\ast }$ as determined below,

  • $C.\mathsf{globals}$ is $\mathrm{globals}({\mathit{it}}^{\ast })$ concatenated with ${\mathit{gt}}^{\ast }$, with the import’s external types ${\mathit{it}}^{\ast }$ and the internal global types ${\mathit{gt}}^{\ast }$ as determined below,

  • $C.\mathsf{elems}$ is ${\mathit{rt}}^{\ast }$ as determined below,

  • $C.\mathsf{datas}$ is ${\text{ok}}^n$, where $n$ is the length of the vector $\mathit{module}.\mathsf{datas}$,

  • $C.\mathsf{locals}$ is empty,

  • $C.\mathsf{labels}$ is empty,

  • $C.\mathsf{return}$ is empty.

  • $C.\mathsf{refs}$ is the set $\mathrm{funcidx}(\mathit{module}\text{with}\mathsf{funcs}=ϵ\text{with}\mathsf{start}=ϵ)$, i.e., the set of function indices occurring in the module, except in its functions or start function.

• Let $C^{\prime }$ be the context where:

  • $C^{\prime }.\mathsf{globals}$ is the sequence $\mathrm{globals}({\mathit{it}}^{\ast })$,

  • $C^{\prime }.\mathsf{types}$ is the same as $C.\mathsf{types}$,

  • $C^{\prime }.\mathsf{funcs}$ is the same as $C.\mathsf{funcs}$,

  • $C^{\prime }.\mathsf{refs}$ is the same as $C.\mathsf{refs}$,

  • all other fields are empty.

• Under the context $C^{\prime }$:

  • The sequence $\mathit{module}.\mathsf{globals}$ of globals must be valid with a sequence ${\mathit{gt}}^{\ast }$ of global types.

  • For each ${\mathit{table}}_i$ in $\mathit{module}.\mathsf{tables}$, the definition ${\mathit{table}}_i$ must be valid with a table type ${\mathit{tt}}_i$.

  • For each ${\mathit{mem}}_i$ in $\mathit{module}.\mathsf{mems}$, the definition ${\mathit{mem}}_i$ must be valid with a memory type ${\mathit{mt}}_i$.

• Under the context $C$:

  • For each ${\mathit{func}}_i$ in $\mathit{module}.\mathsf{funcs}$, the definition ${\mathit{func}}_i$ must be valid with a defined type ${\mathit{dt}}_i$.

  • For each ${\mathit{elem}}_i$ in $\mathit{module}.\mathsf{elems}$, the segment ${\mathit{elem}}_i$ must be valid with reference type ${\mathit{rt}}_i$.

  • For each ${\mathit{data}}_i$ in $\mathit{module}.\mathsf{datas}$, the segment ${\mathit{data}}_i$ must be valid.

  • If $\mathit{module}.\mathsf{start}$ is non-empty, then $\mathit{module}.\mathsf{start}$ must be valid.

  • For each ${\mathit{import}}_i$ in $\mathit{module}.\mathsf{imports}$, the segment ${\mathit{import}}_i$ must be valid with an external type ${\mathit{it}}_i$.

  • For each ${\mathit{export}}_i$ in $\mathit{module}.\mathsf{exports}$, the segment ${\mathit{export}}_i$ must be valid with external type ${\mathit{et}}_i$.

• Let ${\mathit{dt}}^{\ast }$ be the concatenation of the internal function types ${\mathit{dt}}_i$, in index order.

• Let ${\mathit{tt}}^{\ast }$ be the concatenation of the internal table types ${\mathit{tt}}_i$, in index order.

• Let ${\mathit{mt}}^{\ast }$ be the concatenation of the internal memory types ${\mathit{mt}}_i$, in index order.

• Let ${\mathit{rt}}^{\ast }$ be the concatenation of the reference types ${\mathit{rt}}_i$, in index order.

• Let ${\mathit{it}}^{\ast }$ be the concatenation of external types ${\mathit{it}}_i$ of the imports, in index order.

• Let ${\mathit{et}}^{\ast }$ be the concatenation of external types ${\mathit{et}}_i$ of the exports, in index order.

• The length of $C.\mathsf{mems}$ must not be larger than $1$.

• All export names ${\mathit{export}}_i.\mathsf{name}$ must be different.

• Then the module is valid with external types ${\mathit{it}}^{\ast }\to {\mathit{et}}^{\ast }$.

$$\begin{array}{r}\frac{\begin{array}{c}{C}_0⊢{\mathit{type}}^{\ast }\text{ok}{C}^{\prime }⊢{\mathit{global}}^{\ast }:{\mathit{gt}}^{\ast }(C^{\prime }⊢\mathit{table}:\mathit{tt}{)}^{\ast }(C^{\prime }⊢\mathit{mem}:\mathit{mt}{)}^{\ast }(C⊢\mathit{func}:\mathit{dt}{)}^{\ast }\\ (C⊢\mathit{elem}:\mathit{rt}{)}^{\ast }(C⊢\mathit{data}\text{ok}{)}^n(C⊢\mathit{start}\text{ok}{)}^{?}(C⊢\mathit{import}:\mathit{it}{)}^{\ast }(C⊢\mathit{export}:\mathit{et}{)}^{\ast }\\ {\mathit{idt}}^{\ast }=\mathrm{funcs}({\mathit{it}}^{\ast }){\mathit{itt}}^{\ast }=\mathrm{tables}({\mathit{it}}^{\ast }){\mathit{imt}}^{\ast }=\mathrm{mems}({\mathit{it}}^{\ast }){\mathit{igt}}^{\ast }=\mathrm{globals}({\mathit{it}}^{\ast })\\ x^{\ast }=\mathrm{funcidx}(\mathit{module}\text{with}\mathsf{funcs}=ϵ\text{with}\mathsf{start}=ϵ)\\ C=\{\mathsf{types}{C}_0.\mathsf{types},\mathsf{funcs}{\mathit{idt}}^{\ast }{\mathit{dt}}^{\ast },\mathsf{tables}{\mathit{itt}}^{\ast }{\mathit{tt}}^{\ast },\mathsf{mems}{\mathit{imt}}^{\ast }{\mathit{mt}}^{\ast },\mathsf{globals}{\mathit{igt}}^{\ast }{\mathit{gt}}^{\ast },\mathsf{elems}{\mathit{rt}}^{\ast },\mathsf{datas}{\text{ok}}^n,\mathsf{refs}{x}^{\ast }\}\\ C^{\prime }=\{\mathsf{types}{C}_0.\mathsf{types},\mathsf{globals}{\mathit{igt}}^{\ast },\mathsf{funcs}(C.\mathsf{funcs}),\mathsf{refs}(C.\mathsf{refs})\}|C.\mathsf{mems}|\le 1(\mathit{export}.\mathsf{name}{)}^{\ast }\mathrm{disjoint}\\ \mathit{module}=\{\begin{array}{l}\mathsf{types}{\mathit{type}}^{\ast },\mathsf{funcs}{\mathit{func}}^{\ast },\mathsf{tables}{\mathit{table}}^{\ast },\mathsf{mems}{\mathit{mem}}^{\ast },\mathsf{globals}{\mathit{global}}^{\ast },\\ \mathsf{elems}{\mathit{elem}}^{\ast },\mathsf{datas}{\mathit{data}}^n,\mathsf{start}{\mathit{start}}^{?},\mathsf{imports}{\mathit{import}}^{\ast },\mathsf{exports}{\mathit{export}}^{\ast }\}\end{array}\end{array}}{⊢\mathit{module}:{\mathit{it}}^{\ast }\to {\mathit{et}}^{\ast }}\end{array}$$

Note

All functions in a module are mutually recursive. Consequently, the definition of the context $C$ in this rule is recursive: it depends on the outcome of validation of the function, table, memory, and global definitions contained in the module, which itself depends on $C$. However, this recursion is just a specification device. All types needed to construct $C$ can easily be determined from a simple pre-pass over the module that does not perform any actual validation.

Globals, however, are not recursive but evaluated sequentially, such that each constant expressions only has access to imported or previously defined globals.

Note

The restriction on the number of memories may be lifted in future versions of WebAssembly.