Embedding

A WebAssembly implementation will typically be embedded into a host environment. An embedder implements the connection between such a host environment and the WebAssembly semantics as defined in the main body of this specification. An embedder is expected to interact with the semantics in well-defined ways.

This section defines a suitable interface to the WebAssembly semantics in the form of entry points through which an embedder can access it. The interface is intended to be complete, in the sense that an embedder does not need to reference other functional parts of the WebAssembly specification directly.

Note

On the other hand, an embedder does not need to provide the host environment with access to all functionality defined in this interface. For example, an implementation may not support parsing of the text format.

Types

In the description of the embedder interface, syntactic classes from the abstract syntax and the runtime’s abstract machine are used as names for variables that range over the possible objects from that class. Hence, these syntactic classes can also be interpreted as types.

For numeric parameters, notation like $n:\mathit{u}\mathit{32}$ is used to specify a symbolic name in addition to the respective value range.

Errors

Failure of an interface operation is indicated by an auxiliary syntactic class:

$$\begin{array}{r}\begin{array}{llll}& \mathit{error}& ::=& \mathsf{error}\end{array}\end{array}$$

In addition to the error conditions specified explicitly in this section, implementations may also return errors when specific implementation limitations are reached.

Note

Errors are abstract and unspecific with this definition. Implementations can refine it to carry suitable classifications and diagnostic messages.

Pre- and Post-Conditions

Some operations state pre-conditions about their arguments or post-conditions about their results. It is the embedder’s responsibility to meet the pre-conditions. If it does, the post conditions are guaranteed by the semantics.

In addition to pre- and post-conditions explicitly stated with each operation, the specification adopts the following conventions for runtime objects ($\mathit{store}$, $\mathit{moduleinst}$, $\mathit{externval}$, addresses):

• Every runtime object passed as a parameter must be valid per an implicit pre-condition.

• Every runtime object returned as a result is valid per an implicit post-condition.

Note

As long as an embedder treats runtime objects as abstract and only creates and manipulates them through the interface defined here, all implicit pre-conditions are automatically met.

Store

$\mathrm{store}\mathrm{\_}\mathrm{init}():\mathit{store}$

1. Return the empty store.

$$\begin{array}{r}\begin{array}{lcl}\mathrm{store}\mathrm{\_}\mathrm{init}()& =& \{\mathsf{funcs}ϵ,\mathsf{mems}ϵ,\mathsf{tables}ϵ,\mathsf{globals}ϵ\}\end{array}\end{array}$$

Modules

$\mathrm{module}\mathrm{\_}\mathrm{decode}({\mathit{byte}}^{\ast }):\mathit{module}|\mathit{error}$

1. If there exists a derivation for the byte sequence ${\mathit{byte}}^{\ast }$ as a $\mathtt{module}$ according to the binary grammar for modules, yielding a module $m$, then return $m$.

2. Else, return $\mathsf{error}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{module}\mathrm{\_}\mathrm{decode}(b^{\ast })& =& m& & (\text{if}\mathtt{module}\stackrel{\ast }{⟹}m:b^{\ast })\\ \mathrm{module}\mathrm{\_}\mathrm{decode}(b^{\ast })& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

$\mathrm{module}\mathrm{\_}\mathrm{parse}({\mathit{char}}^{\ast }):\mathit{module}|\mathit{error}$

1. If there exists a derivation for the source ${\mathit{char}}^{\ast }$ as a $\mathtt{module}$ according to the text grammar for modules, yielding a module $m$, then return $m$.

2. Else, return $\mathsf{error}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{module}\mathrm{\_}\mathrm{parse}(c^{\ast })& =& m& & (\text{if}\mathtt{module}\stackrel{\ast }{⟹}m:c^{\ast })\\ \mathrm{module}\mathrm{\_}\mathrm{parse}(c^{\ast })& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

$\mathrm{module}\mathrm{\_}\mathrm{validate}(\mathit{module}):{\mathit{error}}^{?}$

1. If $\mathit{module}$ is valid, then return nothing.

2. Else, return $\mathsf{error}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{module}\mathrm{\_}\mathrm{validate}(m)& =& ϵ& & (\text{if}⊢m:{\mathit{externtype}}^{\ast }\to {{\mathit{externtype}}^{\prime }}^{\ast })\\ \mathrm{module}\mathrm{\_}\mathrm{validate}(m)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

$\mathrm{module}\mathrm{\_}\mathrm{instantiate}(\mathit{store},\mathit{module},{\mathit{externval}}^{\ast }):(\mathit{store},\mathit{moduleinst}|\mathit{error})$

1. Try instantiating $\mathit{module}$ in $\mathit{store}$ with external values ${\mathit{externval}}^{\ast }$ as imports:

1. If it succeeds with a module instance $\mathit{moduleinst}$, then let $\mathit{result}$ be $\mathit{moduleinst}$.

2. Else, let $\mathit{result}$ be $\mathsf{error}$.

2. Return the new store paired with $\mathit{result}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{module}\mathrm{\_}\mathrm{instantiate}(S,m,{\mathit{ev}}^{\ast })& =& (S^{\prime },F.\mathsf{module})& & (\text{if}\mathrm{instantiate}(S,m,{\mathit{ev}}^{\ast }){\hookrightarrow }^{\ast }{S}^{\prime };F;ϵ)\\ \mathrm{module}\mathrm{\_}\mathrm{instantiate}(S,m,{\mathit{ev}}^{\ast })& =& (S^{\prime },\mathsf{error})& & (\text{if}\mathrm{instantiate}(S,m,{\mathit{ev}}^{\ast }){\hookrightarrow }^{\ast }{S}^{\prime };F;\mathsf{trap})\end{array}\end{array}$$

Note

The store may be modified even in case of an error.

$\mathrm{module}\mathrm{\_}\mathrm{imports}(\mathit{module}):(\mathit{name},\mathit{name},\mathit{externtype}{)}^{\ast }$

1. Pre-condition: $\mathit{module}$ is valid with external import types ${\mathit{externtype}}^{\ast }$ and external export types ${{\mathit{externtype}}^{\prime }}^{\ast }$.

2. Let ${\mathit{import}}^{\ast }$ be the imports $\mathit{module}.\mathsf{imports}$.

3. Assert: the length of ${\mathit{import}}^{\ast }$ equals the length of ${\mathit{externtype}}^{\ast }$.

4. For each ${\mathit{import}}_i$ in ${\mathit{import}}^{\ast }$ and corresponding ${\mathit{externtype}}_i$ in ${\mathit{externtype}}^{\ast }$, do:

1. Let ${\mathit{result}}_i$ be the triple $({\mathit{import}}_i.\mathsf{module},{\mathit{import}}_i.\mathsf{name},{\mathit{externtype}}_i)$.

5. Return the concatenation of all ${\mathit{result}}_i$, in index order.

6. Post-condition: each ${\mathit{externtype}}_i$ is valid.

$$\begin{array}{r}\\ \begin{array}{lcl}\mathrm{module}\mathrm{\_}\mathrm{imports}(m)& =& (\mathit{im}.\mathsf{module},\mathit{im}.\mathsf{name},\mathit{externtype}{)}^{\ast }\\ & & (\text{if}{\mathit{im}}^{\ast }=m.\mathsf{imports}\wedge ⊢m:{\mathit{externtype}}^{\ast }\to {{\mathit{externtype}}^{\prime }}^{\ast })\end{array}\end{array}$$

$\mathrm{module}\mathrm{\_}\mathrm{exports}(\mathit{module}):(\mathit{name},\mathit{externtype}{)}^{\ast }$

1. Pre-condition: $\mathit{module}$ is valid with external import types ${\mathit{externtype}}^{\ast }$ and external export types ${{\mathit{externtype}}^{\prime }}^{\ast }$.

2. Let ${\mathit{export}}^{\ast }$ be the exports $\mathit{module}.\mathsf{exports}$.

3. Assert: the length of ${\mathit{export}}^{\ast }$ equals the length of ${{\mathit{externtype}}^{\prime }}^{\ast }$.

4. For each ${\mathit{export}}_i$ in ${\mathit{export}}^{\ast }$ and corresponding ${\mathit{externtype}}_i^{\prime }$ in ${{\mathit{externtype}}^{\prime }}^{\ast }$, do:

1. Let ${\mathit{result}}_i$ be the pair $({\mathit{export}}_i.\mathsf{name},{\mathit{externtype}}_i^{\prime })$.

5. Return the concatenation of all ${\mathit{result}}_i$, in index order.

6. Post-condition: each ${\mathit{externtype}}_i^{\prime }$ is valid.

$$\begin{array}{r}\\ \begin{array}{lcl}\mathrm{module}\mathrm{\_}\mathrm{exports}(m)& =& (\mathit{ex}.\mathsf{name},{\mathit{externtype}}^{\prime }{)}^{\ast }\\ & & (\text{if}{\mathit{ex}}^{\ast }=m.\mathsf{exports}\wedge ⊢m:{\mathit{externtype}}^{\ast }\to {{\mathit{externtype}}^{\prime }}^{\ast })\end{array}\end{array}$$

Module Instances

$\mathrm{instance}\mathrm{\_}\mathrm{export}(\mathit{moduleinst},\mathit{name}):\mathit{externval}|\mathit{error}$

1. Assert: due to validity of the module instance $\mathit{moduleinst}$, all its export names are different.

2. If there exists an ${\mathit{exportinst}}_i$ in $\mathit{moduleinst}.\mathsf{exports}$ such that name ${\mathit{exportinst}}_i.\mathsf{name}$ equals $\mathit{name}$, then:

   1. Return the external value ${\mathit{exportinst}}_i.\mathsf{value}$.

3. Else, return $\mathsf{error}$.

$$\begin{array}{r}\\ \begin{array}{lclll}\mathrm{instance}\mathrm{\_}\mathrm{export}(m,\mathit{name})& =& m.\mathsf{exports}[i].\mathsf{value}& & (\text{if}m.\mathsf{exports}[i].\mathsf{name}=\mathit{name})\\ \mathrm{instance}\mathrm{\_}\mathrm{export}(m,\mathit{name})& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

Functions

$\mathrm{func}\mathrm{\_}\mathrm{alloc}(\mathit{store},\mathit{functype},\mathit{hostfunc}):(\mathit{store},\mathit{funcaddr})$

1. Pre-condition: $\mathit{functype}$ is valid.

2. Let $\mathit{funcaddr}$ be the result of allocating a host function in $\mathit{store}$ with function type $\mathit{functype}$ and host function code $\mathit{hostfunc}$.

3. Return the new store paired with $\mathit{funcaddr}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{func}\mathrm{\_}\mathrm{alloc}(S,\mathit{ft},\mathit{code})& =& (S^{\prime },\mathit{a})& & (\text{if}\mathrm{allochostfunc}(S,\mathit{ft},\mathit{code})=S^{\prime },\mathit{a})\end{array}\end{array}$$

Note

This operation assumes that $\mathit{hostfunc}$ satisfies the pre- and post-conditions required for a function instance with type $\mathit{functype}$.

Regular (non-host) function instances can only be created indirectly through module instantiation.

$\mathrm{func}\mathrm{\_}\mathrm{type}(\mathit{store},\mathit{funcaddr}):\mathit{functype}$

1. Return $S.\mathsf{funcs}[a].\mathsf{type}$.

2. Post-condition: the returned function type is valid.

$$\begin{array}{r}\begin{array}{lcl}\mathrm{func}\mathrm{\_}\mathrm{type}(S,a)& =& S.\mathsf{funcs}[a].\mathsf{type}\end{array}\end{array}$$

$\mathrm{func}\mathrm{\_}\mathrm{invoke}(\mathit{store},\mathit{funcaddr},{\mathit{val}}^{\ast }):(\mathit{store},{\mathit{val}}^{\ast }|\mathit{error})$

1. Try invoking the function $\mathit{funcaddr}$ in $\mathit{store}$ with values ${\mathit{val}}^{\ast }$ as arguments:

1. If it succeeds with values ${{\mathit{val}}^{\prime }}^{\ast }$ as results, then let $\mathit{result}$ be ${{\mathit{val}}^{\prime }}^{\ast }$.

2. Else it has trapped, hence let $\mathit{result}$ be $\mathsf{error}$.

2. Return the new store paired with $\mathit{result}$.

$$\begin{array}{r}\\ \begin{array}{lclll}\mathrm{func}\mathrm{\_}\mathrm{invoke}(S,a,v^{\ast })& =& (S^{\prime },{v^{\prime }}^{\ast })& & (\text{if}\mathrm{invoke}(S,a,v^{\ast }){\hookrightarrow }^{\ast }{S}^{\prime };F;{v^{\prime }}^{\ast })\\ \mathrm{func}\mathrm{\_}\mathrm{invoke}(S,a,v^{\ast })& =& (S^{\prime },\mathsf{error})& & (\text{if}\mathrm{invoke}(S,a,v^{\ast }){\hookrightarrow }^{\ast }{S}^{\prime };F;\mathsf{trap})\end{array}\end{array}$$

Note

The store may be modified even in case of an error.

Tables

$\mathrm{table}\mathrm{\_}\mathrm{alloc}(\mathit{store},\mathit{tabletype},\mathit{ref}):(\mathit{store},\mathit{tableaddr})$

1. Pre-condition: $\mathit{tabletype}$ is valid.

2. Let $\mathit{tableaddr}$ be the result of allocating a table in $\mathit{store}$ with table type $\mathit{tabletype}$ and initialization value $\mathit{ref}$.

3. Return the new store paired with $\mathit{tableaddr}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{table}\mathrm{\_}\mathrm{alloc}(S,\mathit{tt},r)& =& (S^{\prime },\mathit{a})& & (\text{if}\mathrm{alloctable}(S,\mathit{tt},r)=S^{\prime },\mathit{a})\end{array}\end{array}$$

$\mathrm{table}\mathrm{\_}\mathrm{type}(\mathit{store},\mathit{tableaddr}):\mathit{tabletype}$

1. Return $S.\mathsf{tables}[a].\mathsf{type}$.

2. Post-condition: the returned table type is valid.

$$\begin{array}{r}\begin{array}{lcl}\mathrm{table}\mathrm{\_}\mathrm{type}(S,a)& =& S.\mathsf{tables}[a].\mathsf{type}\end{array}\end{array}$$

$\mathrm{table}\mathrm{\_}\mathrm{read}(\mathit{store},\mathit{tableaddr},i:\mathit{u}\mathit{32}):\mathit{ref}|\mathit{error}$

1. Let $\mathit{ti}$ be the table instance $\mathit{store}.\mathsf{tables}[\mathit{tableaddr}]$.

2. If $i$ is larger than or equal to the length of $\mathit{ti}.\mathsf{elem}$, then return $\mathsf{error}$.

3. Else, return the reference value $\mathit{ti}.\mathsf{elem}[i]$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{table}\mathrm{\_}\mathrm{read}(S,a,i)& =& r& & (\text{if}S.\mathsf{tables}[a].\mathsf{elem}[i]=r)\\ \mathrm{table}\mathrm{\_}\mathrm{read}(S,a,i)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

$\mathrm{table}\mathrm{\_}\mathrm{write}(\mathit{store},\mathit{tableaddr},i:\mathit{u}\mathit{32},\mathit{ref}):\mathit{store}|\mathit{error}$

1. Let $\mathit{ti}$ be the table instance $\mathit{store}.\mathsf{tables}[\mathit{tableaddr}]$.

2. If $i$ is larger than or equal to the length of $\mathit{ti}.\mathsf{elem}$, then return $\mathsf{error}$.

3. Replace $\mathit{ti}.\mathsf{elem}[i]$ with the reference value $\mathit{ref}$.

4. Return the updated store.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{table}\mathrm{\_}\mathrm{write}(S,a,i,r)& =& S^{\prime }& & (\text{if}{S}^{\prime }=S\text{with}\mathsf{tables}[a].\mathsf{elem}[i]=r)\\ \mathrm{table}\mathrm{\_}\mathrm{write}(S,a,i,r)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

$\mathrm{table}\mathrm{\_}\mathrm{size}(\mathit{store},\mathit{tableaddr}):\mathit{u}\mathit{32}$

1. Return the length of $\mathit{store}.\mathsf{tables}[\mathit{tableaddr}].\mathsf{elem}$.

$$\begin{array}{r}\\ \begin{array}{lclll}\mathrm{table}\mathrm{\_}\mathrm{size}(S,a)& =& n& & (\text{if}|S.\mathsf{tables}[a].\mathsf{elem}|=n)\end{array}\end{array}$$

$\mathrm{table}\mathrm{\_}\mathrm{grow}(\mathit{store},\mathit{tableaddr},n:\mathit{u}\mathit{32},\mathit{ref}):\mathit{store}|\mathit{error}$

1. Try growing the table instance $\mathit{store}.\mathsf{tables}[\mathit{tableaddr}]$ by $n$ elements with initialization value $\mathit{ref}$:

   1. If it succeeds, return the updated store.

   2. Else, return $\mathsf{error}$.

$$\begin{array}{r}\\ \begin{array}{lclll}\mathrm{table}\mathrm{\_}\mathrm{grow}(S,a,n,r)& =& S^{\prime }& & (\text{if}{S}^{\prime }=S\text{with}\mathsf{tables}[a]=\mathrm{growtable}(S.\mathsf{tables}[a],n,r))\\ \mathrm{table}\mathrm{\_}\mathrm{grow}(S,a,n,r)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

Memories

$\mathrm{mem}\mathrm{\_}\mathrm{alloc}(\mathit{store},\mathit{memtype}):(\mathit{store},\mathit{memaddr})$

1. Pre-condition: $\mathit{memtype}$ is valid.

2. Let $\mathit{memaddr}$ be the result of allocating a memory in $\mathit{store}$ with memory type $\mathit{memtype}$.

3. Return the new store paired with $\mathit{memaddr}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{mem}\mathrm{\_}\mathrm{alloc}(S,\mathit{mt})& =& (S^{\prime },\mathit{a})& & (\text{if}\mathrm{allocmem}(S,\mathit{mt})=S^{\prime },\mathit{a})\end{array}\end{array}$$

$\mathrm{mem}\mathrm{\_}\mathrm{type}(\mathit{store},\mathit{memaddr}):\mathit{memtype}$

1. Return $S.\mathsf{mems}[a].\mathsf{type}$.

2. Post-condition: the returned memory type is valid.

$$\begin{array}{r}\begin{array}{lcl}\mathrm{mem}\mathrm{\_}\mathrm{type}(S,a)& =& S.\mathsf{mems}[a].\mathsf{type}\end{array}\end{array}$$

$\mathrm{mem}\mathrm{\_}\mathrm{read}(\mathit{store},\mathit{memaddr},i:\mathit{u}\mathit{32}):\mathit{byte}|\mathit{error}$

1. Let $\mathit{mi}$ be the memory instance $\mathit{store}.\mathsf{mems}[\mathit{memaddr}]$.

2. If $i$ is larger than or equal to the length of $\mathit{mi}.\mathsf{data}$, then return $\mathsf{error}$.

3. Else, return the byte $\mathit{mi}.\mathsf{data}[i]$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{mem}\mathrm{\_}\mathrm{read}(S,a,i)& =& b& & (\text{if}S.\mathsf{mems}[a].\mathsf{data}[i]=b)\\ \mathrm{mem}\mathrm{\_}\mathrm{read}(S,a,i)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

$\mathrm{mem}\mathrm{\_}\mathrm{write}(\mathit{store},\mathit{memaddr},i:\mathit{u}\mathit{32},\mathit{byte}):\mathit{store}|\mathit{error}$

1. Let $\mathit{mi}$ be the memory instance $\mathit{store}.\mathsf{mems}[\mathit{memaddr}]$.

2. If $\mathit{u}\mathit{32}$ is larger than or equal to the length of $\mathit{mi}.\mathsf{data}$, then return $\mathsf{error}$.

3. Replace $\mathit{mi}.\mathsf{data}[i]$ with $\mathit{byte}$.

4. Return the updated store.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{mem}\mathrm{\_}\mathrm{write}(S,a,i,b)& =& S^{\prime }& & (\text{if}{S}^{\prime }=S\text{with}\mathsf{mems}[a].\mathsf{data}[i]=b)\\ \mathrm{mem}\mathrm{\_}\mathrm{write}(S,a,i,b)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

$\mathrm{mem}\mathrm{\_}\mathrm{size}(\mathit{store},\mathit{memaddr}):\mathit{u}\mathit{32}$

1. Return the length of $\mathit{store}.\mathsf{mems}[\mathit{memaddr}].\mathsf{data}$ divided by the page size.

$$\begin{array}{r}\\ \begin{array}{lclll}\mathrm{mem}\mathrm{\_}\mathrm{size}(S,a)& =& n& & (\text{if}|S.\mathsf{mems}[a].\mathsf{data}|=n\cdot 64\mathrm{Ki})\end{array}\end{array}$$

$\mathrm{mem}\mathrm{\_}\mathrm{grow}(\mathit{store},\mathit{memaddr},n:\mathit{u}\mathit{32}):\mathit{store}|\mathit{error}$

1. Try growing the memory instance $\mathit{store}.\mathsf{mems}[\mathit{memaddr}]$ by $n$ pages:

   1. If it succeeds, return the updated store.

   2. Else, return $\mathsf{error}$.

$$\begin{array}{r}\\ \begin{array}{lclll}\mathrm{mem}\mathrm{\_}\mathrm{grow}(S,a,n)& =& S^{\prime }& & (\text{if}{S}^{\prime }=S\text{with}\mathsf{mems}[a]=\mathrm{growmem}(S.\mathsf{mems}[a],n))\\ \mathrm{mem}\mathrm{\_}\mathrm{grow}(S,a,n)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$

Globals

$\mathrm{global}\mathrm{\_}\mathrm{alloc}(\mathit{store},\mathit{globaltype},\mathit{val}):(\mathit{store},\mathit{globaladdr})$

1. Pre-condition: $\mathit{globaltype}$ is valid.

2. Let $\mathit{globaladdr}$ be the result of allocating a global in $\mathit{store}$ with global type $\mathit{globaltype}$ and initialization value $\mathit{val}$.

3. Return the new store paired with $\mathit{globaladdr}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{global}\mathrm{\_}\mathrm{alloc}(S,\mathit{gt},v)& =& (S^{\prime },\mathit{a})& & (\text{if}\mathrm{allocglobal}(S,\mathit{gt},v)=S^{\prime },\mathit{a})\end{array}\end{array}$$

$\mathrm{global}\mathrm{\_}\mathrm{type}(\mathit{store},\mathit{globaladdr}):\mathit{globaltype}$

1. Return $S.\mathsf{globals}[a].\mathsf{type}$.

2. Post-condition: the returned global type is valid.

$$\begin{array}{r}\begin{array}{lcl}\mathrm{global}\mathrm{\_}\mathrm{type}(S,a)& =& S.\mathsf{globals}[a].\mathsf{type}\end{array}\end{array}$$

$\mathrm{global}\mathrm{\_}\mathrm{read}(\mathit{store},\mathit{globaladdr}):\mathit{val}$

1. Let $\mathit{gi}$ be the global instance $\mathit{store}.\mathsf{globals}[\mathit{globaladdr}]$.

2. Return the value $\mathit{gi}.\mathsf{value}$.

$$\begin{array}{r}\begin{array}{lclll}\mathrm{global}\mathrm{\_}\mathrm{read}(S,a)& =& v& & (\text{if}S.\mathsf{globals}[a].\mathsf{value}=v)\end{array}\end{array}$$

$\mathrm{global}\mathrm{\_}\mathrm{write}(\mathit{store},\mathit{globaladdr},\mathit{val}):\mathit{store}|\mathit{error}$

1. Let $\mathit{gi}$ be the global instance $\mathit{store}.\mathsf{globals}[\mathit{globaladdr}]$.

2. Let $\mathit{mut}t$ be the structure of the global type $\mathit{gi}.\mathsf{type}$.

3. If $\mathit{mut}$ is not $\mathsf{var}$, then return $\mathsf{error}$.

4. Replace $\mathit{gi}.\mathsf{value}$ with the value $\mathit{val}$.

5. Return the updated store.

$$\begin{array}{r}\\ \begin{array}{lclll}\mathrm{global}\mathrm{\_}\mathrm{write}(S,a,v)& =& S^{\prime }& & (\text{if}S.\mathsf{globals}[a].\mathsf{type}=\mathsf{var}t\wedge S^{\prime }=S\text{with}\mathsf{globals}[a].\mathsf{value}=v)\\ \mathrm{global}\mathrm{\_}\mathrm{write}(S,a,v)& =& \mathsf{error}& & (\text{otherwise})\end{array}\end{array}$$