Numeric Instructions
Numeric instructions are defined in terms of the generic numeric operators.
The mapping of numeric instructions to their underlying operators is expressed by the following definition:
\[\begin{split}\begin{array}{lll@{\qquad}l}
\mathit{op}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}}(i_1,\dots,i_k) &=& \mathrm{i}\mathit{op}_N(i_1,\dots,i_k) \\
\mathit{op}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{f}N}}(z_1,\dots,z_k) &=& \mathrm{f}\mathit{op}_N(z_1,\dots,z_k) \\
\mathit{op}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{v}N}}(i_1,\dots,i_k) &=& \mathrm{i}\mathit{op}_N(i_1,\dots,i_k) \\
\end{array}\end{split}\]
And for conversion operators:
\[\begin{split}\begin{array}{lll@{\qquad}l}
\mathit{cvtop}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{t_1,t_2}(c) &=& \mathit{cvtop}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{|t_1|,|t_2|}(c) \\
\end{array}\end{split}\]
Where the underlying operators are partial, the corresponding instruction will trap when the result is not defined.
Where the underlying operators are non-deterministic, because they may return one of multiple possible NaN values, so are the corresponding instructions.
Note
For example, the result of instruction \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}}\) applied to operands \(i_1, i_2\)
invokes \(\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}}(i_1, i_2)\),
which maps to the generic \(\href{../exec/numerics.html#op-iadd}{\mathrm{iadd}}_{32}(i_1, i_2)\) via the above definition.
Similarly, \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{f32}}\mathsf{\_s}\) applied to \(z\)
invokes \(\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}^{\mathsf{s}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{f32}},\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}}(z)\),
which maps to the generic \(\href{../exec/numerics.html#op-trunc-s}{\mathrm{trunc}^{\mathsf{s}}}_{32,64}(z)\).
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\)
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
Note
No formal reduction rule is required for this instruction, since \(\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}\) instructions already are values.
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}\)
Assert: due to validation, a value of value type \(t\) is on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) from the stack.
If \(\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}_t(c_1)\) is defined, then:
Let \(c\) be a possible result of computing \(\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}_t(c_1)\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
Else:
Trap.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~t\mathsf{.}\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c \in \href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}_t(c_1)) \\
(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~t\mathsf{.}\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
& (\mathrel{\mbox{if}} \href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}_{t}(c_1) = \{\})
\end{array}\end{split}\]
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}\)
Assert: due to validation, two values of value type \(t\) are on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) from the stack.
If \(\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}_t(c_1, c_2)\) is defined, then:
Let \(c\) be a possible result of computing \(\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}_t(c_1, c_2)\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
Else:
Trap.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~t\mathsf{.}\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c \in \href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}_t(c_1,c_2)) \\
(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~t\mathsf{.}\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
& (\mathrel{\mbox{if}} \href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}_{t}(c_1,c_2) = \{\})
\end{array}\end{split}\]
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-testop}{\mathit{testop}}\)
Assert: due to validation, a value of value type \(t\) is on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) from the stack.
Let \(c\) be the result of computing \(\href{../syntax/instructions.html#syntax-testop}{\mathit{testop}}_t(c_1)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~t\mathsf{.}\href{../syntax/instructions.html#syntax-testop}{\mathit{testop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c = \href{../syntax/instructions.html#syntax-testop}{\mathit{testop}}_t(c_1)) \\
\end{array}\end{split}\]
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-relop}{\mathit{relop}}\)
Assert: due to validation, two values of value type \(t\) are on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) from the stack.
Let \(c\) be the result of computing \(\href{../syntax/instructions.html#syntax-relop}{\mathit{relop}}_t(c_1, c_2)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~t\mathsf{.}\href{../syntax/instructions.html#syntax-relop}{\mathit{relop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c = \href{../syntax/instructions.html#syntax-relop}{\mathit{relop}}_t(c_1,c_2)) \\
\end{array}\end{split}\]
\(t_2\mathsf{.}\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}\mathsf{\_}t_1\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?\)
Assert: due to validation, a value of value type \(t_1\) is on the top of the stack.
Pop the value \(t_1.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) from the stack.
If \(\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{t_1,t_2}(c_1)\) is defined:
Let \(c_2\) be a possible result of computing \(\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{t_1,t_2}(c_1)\).
Push the value \(t_2.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2\) to the stack.
Else:
Trap.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(t_1\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~t_2\mathsf{.}\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}\mathsf{\_}t_1\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^? &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (t_2\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)
& (\mathrel{\mbox{if}} c_2 \in \href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{t_1,t_2}(c_1)) \\
(t_1\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~t_2\mathsf{.}\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}\mathsf{\_}t_1\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^? &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
& (\mathrel{\mbox{if}} \href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{t_1,t_2}(c_1) = \{\})
\end{array}\end{split}\]
Vector Instructions
Most vector instructions are defined in terms of generic numeric operators applied lane-wise based on the shape.
\[\begin{array}{lll@{\qquad}l}
\mathit{op}_{t\mathsf{x}N}(n_1,\dots,n_k) &=&
\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t\mathsf{x}N}(op_t(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(n_1) ~\dots~ \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(n_k))
\end{array}\]
Note
For example, the result of instruction \(\mathsf{i32x4}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}}\) applied to operands \(i_1, i_2\)
invokes \(\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}}_{\mathsf{i32x4}}(i_1, i_2)\), which maps to
\(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\mathsf{i32x4}}(\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}}(i_1^+, i_2^+))\),
where \(i_1^+\) and \(i_2^+\) are sequences resulting from invoking
\(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\mathsf{i32x4}}(i_1)\) and \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\mathsf{i32x4}}(i_2)\)
respectively.
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\)
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
Note
No formal reduction rule is required for this instruction, since \(\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}\) instructions coincide with values.
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-vvunop}{\mathit{vvunop}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(c\) be the result of computing \(\href{../syntax/instructions.html#syntax-vvunop}{\mathit{vvunop}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}}(c_1)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-vvunop}{\mathit{vvunop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c = \href{../syntax/instructions.html#syntax-vvunop}{\mathit{vvunop}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}}(c_1)) \\
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-vvbinop}{\mathit{vvbinop}}\)
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(c\) be the result of computing \(\href{../syntax/instructions.html#syntax-vvbinop}{\mathit{vvbinop}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}}(c_1, c_2)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-vvbinop}{\mathit{vvbinop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c = \href{../syntax/instructions.html#syntax-vvbinop}{\mathit{vvbinop}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}}(c_1, c_2)) \\
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-vvternop}{\mathit{vvternop}}\)
Assert: due to validation, three values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_3\) from the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(c\) be the result of computing \(\href{../syntax/instructions.html#syntax-vvternop}{\mathit{vvternop}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}}(c_1, c_2, c_3)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_3)~\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-vvternop}{\mathit{vvternop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c = \href{../syntax/instructions.html#syntax-vvternop}{\mathit{vvternop}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}}(c_1, c_2, c_3)) \\
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{any\_true}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i\) be the result of computing \(\href{../exec/numerics.html#op-ine}{\mathrm{ine}}_{128}(c_1, 0)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) onto the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{any\_true}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)
& (\mathrel{\mbox{if}} i = \href{../exec/numerics.html#op-ine}{\mathrm{ine}}_{128}(c_1, 0)) \\
\end{array}\end{split}\]
\(\mathsf{i8x16.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{swizzle}}\)
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Let \(i^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_2)\).
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(j^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_1)\).
Let \(c^\ast\) be the concatenation of the two sequences \(j^\ast\) and \(0^{240}\).
Let \(c'\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ])\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c'\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{swizzle}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c')
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & i^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_2) \\
\wedge & c^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_1)~0^{240} \\
\wedge & c' = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ]))
\end{array}
\end{array}\end{split}\]
\(\mathsf{i8x16.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{shuffle}}~x^\ast\)
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Assert: due to validation, for all \(x_i\) in \(x^\ast\) it holds that \(x_i < 32\).
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Let \(i_2^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_2)\).
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i_1^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_1)\).
Let \(i^\ast\) be the concatenation of the two sequences \(i_1^\ast\) and \(i_2^\ast\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]])\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{shuffle}}~x^\ast) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & i^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_1)~\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(c_2) \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i8x16}}}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]]))
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{splat}}\)
Let \(t\) be the type \(\href{../valid/instructions.html#aux-unpacked}{\mathrm{unpacked}}(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}})\).
Assert: due to validation, a value of value type \(t\) is on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) from the stack.
Let \(N\) be the integer \(\href{../valid/instructions.html#aux-dim}{\mathrm{dim}}(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}})\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1^N)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{splat}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} t = \href{../valid/instructions.html#aux-unpacked}{\mathrm{unpacked}}(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}})
\wedge c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1^{\href{../valid/instructions.html#aux-dim}{\mathrm{dim}}(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}})}))
\\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{replace\_lane}}~x\)
Assert: due to validation, \(x < \href{../valid/instructions.html#aux-dim}{\mathrm{dim}}(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}})\).
Let \(t_1\) be the type \(\href{../valid/instructions.html#aux-unpacked}{\mathrm{unpacked}}(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}})\).
Assert: due to validation, a value of value type \(t_1\) is on the top of the stack.
Pop the value \(t_1.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Let \(i^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_2)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(i^\ast \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} [x] = c_1)\).
Push \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) on the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(t_1\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{replace\_lane}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & i^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_2) \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(i^\ast \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} [x] = c_1))
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-vunop}{\mathit{vunop}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(c\) be the result of computing \(\href{../syntax/instructions.html#syntax-vunop}{\mathit{vunop}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-vunop}{\mathit{vunop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c = \href{../syntax/instructions.html#syntax-vunop}{\mathit{vunop}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1))
\end{array}\]
\(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}\)
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
If \(\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1, c_2)\) is defined:
Let \(c\) be a possible result of computing \(\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1, c_2)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
Else:
Trap.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c \in \href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1, c_2)) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
& (\mathrel{\mbox{if}} \href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1, c_2) = \{\})
\end{array}\end{split}\]
\(t\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vrelop}{\mathit{vrelop}}\)
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i_1^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c_1)\).
Let \(i_2^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c_2)\).
Let \(i^\ast\) be the result of computing \(\href{../syntax/instructions.html#syntax-vrelop}{\mathit{vrelop}}_t(i_1^\ast, i_2^\ast)\).
Let \(j^\ast\) be the result of computing \(\href{../exec/numerics.html#op-extend-s}{\mathrm{extend}^{\mathsf{s}}}_{1,|t|}(i^\ast)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t\mathsf{x}N}(j^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~t\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vrelop}{\mathit{vrelop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t\mathsf{x}N}(\href{../exec/numerics.html#op-extend-s}{\mathrm{extend}^{\mathsf{s}}}_{1,|t|}(\href{../syntax/instructions.html#syntax-vrelop}{\mathit{vrelop}}_t(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c_1), \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c_2)))))
\end{array}
\end{array}\end{split}\]
\(t\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vishiftop}{\mathit{vishiftop}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c_1)\).
Let \(j^\ast\) be the result of computing \(\href{../syntax/instructions.html#syntax-vishiftop}{\mathit{vishiftop}}_{t}(i^\ast, s^N)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t\mathsf{x}N}(j^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~t\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vishiftop}{\mathit{vishiftop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & i^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c_1) \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t\mathsf{x}N}(\href{../syntax/instructions.html#syntax-vishiftop}{\mathit{vishiftop}}_{t}(i^\ast, s^N)))
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{all\_true}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i_1^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c_1)\).
Let \(i\) be the result of computing \(\href{../exec/numerics.html#aux-bool}{\mathrm{bool}}(\bigwedge(i_1 \neq 0)^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{all\_true}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & i_1^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/instructions.html#syntax-shape}{\mathit{shape}}}(c) \\
\wedge & i = \href{../exec/numerics.html#aux-bool}{\mathrm{bool}}(\bigwedge(i_1 \neq 0)^\ast))
\end{array}
\end{array}\end{split}\]
\(t\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{bitmask}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i_1^N\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c)\).
Let \(B\) be the bit width \(|t|\) of value type \(t\).
Let \(i_2^N\) be the result of computing \(\href{../exec/numerics.html#op-ilt-s}{\mathrm{ilt\_s}}_{B}(i_1^N, 0^N)\).
Let \(j^\ast\) be the concatenation of the two sequences \(i_2^N\) and \(0^{32-N}\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-ibits}{\mathrm{ibits}}_{32}^{-1}(j^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~t\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{bitmask}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
& (\mathrel{\mbox{if}} c = \href{../exec/numerics.html#aux-ibits}{\mathrm{ibits}}_{32}^{-1}(\href{../exec/numerics.html#op-ilt-s}{\mathrm{ilt\_s}}_{|t|}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t\mathsf{x}N}(c), 0^N)))
\\
\end{array}\end{split}\]
\(t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{narrow}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}\)
Assert: due to syntax, \(N = 2\cdot M\).
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Let \(i_2^M\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_2)\).
Let \(d_2^M\) be the result of computing \(\href{../exec/numerics.html#op-narrow-u}{\mathrm{narrow}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(i_2^M)\).
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i_1^M\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)\).
Let \(d_1^M\) be the result of computing \(\href{../exec/numerics.html#op-narrow-u}{\mathrm{narrow}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(i_1^M)\).
Let \(j^N\) be the concatenation of the two sequences \(d_1^M\) and \(d_2^M\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(j^N)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{narrow}}\_t_1\mathsf{x}M\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & d_1^M = \href{../exec/numerics.html#op-narrow-u}{\mathrm{narrow}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}( \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)) \\
\wedge & d_2^M = \href{../exec/numerics.html#op-narrow-u}{\mathrm{narrow}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}( \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_2)) \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(d_1^M~d_2^M))
\end{array}
\end{array}\end{split}\]
\(t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}\)
Assert: due to syntax, \(N = M\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)\).
Let \(j^\ast\) be the result of computing \(\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(i^\ast)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(j^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c) \\
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1))))
\end{array}
\end{array}\end{split}\]
\(t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}\mathsf{\_}\href{../syntax/instructions.html#syntax-half}{\mathit{half}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?\)
Assert: due to syntax, \(N = M / 2\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)\).
If \(\href{../syntax/instructions.html#syntax-half}{\mathit{half}}\) is \(\mathsf{low}\), then:
Let \(j^\ast\) be the sequence \(i^\ast[0 \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N]\).
Else:
Let \(j^\ast\) be the sequence \(i^\ast[N \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N]\).
Let \(k^\ast\) be the result of computing \(\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{|t_1|,|t_2|}(j^\ast)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(k^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}\mathsf{\_}\href{../syntax/instructions.html#syntax-half}{\mathit{half}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^? &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c) \\
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}^?}_{|t_1|,|t_2|}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)[\href{../syntax/instructions.html#syntax-half}{\mathit{half}}(0, N) \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N])))
\end{array}
\end{array}\end{split}\]
where:
\[\begin{split}\begin{array}{lcl}
\mathsf{low}(x, y) &=& x \\
\mathsf{high}(x, y) &=& y \\
\end{array}\end{split}\]
\(t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}\mathsf{\_zero}\)
Assert: due to syntax, \(N = 2 \cdot M\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)\).
Let \(j^\ast\) be the result of computing \(\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(i^\ast)\).
Let \(k^\ast\) be the concatenation of the two sequences \(j^\ast\) and \(0^M\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(k^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}\mathsf{\_zero} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c) \\
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1))~0^M))
\end{array}
\end{array}\end{split}\]
\(\mathsf{i32x4.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{dot}}\mathsf{\_i16x8\_s}\)
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i_1^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i16x8}}}(c_1)\).
Let \(j_1^\ast\) be the result of computing \(\href{../exec/numerics.html#op-extend-s}{\mathrm{extend}^{\mathsf{s}}}_{16,32}(i_1^\ast)\).
Let \(i_2^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i16x8}}}(c_2)\).
Let \(j_2^\ast\) be the result of computing \(\href{../exec/numerics.html#op-extend-s}{\mathrm{extend}^{\mathsf{s}}}_{16,32}(i_2^\ast)\).
Let \((k_1~k_2)^\ast\) be the result of computing \(\href{../exec/numerics.html#op-imul}{\mathrm{imul}}_{32}(j_1^\ast, j_2^\ast)\).
Let \(k^\ast\) be the result of computing \(\href{../exec/numerics.html#op-iadd}{\mathrm{iadd}}_{32}(k_1, k_2)^\ast\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i32x4}}}(k^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~\mathsf{i32x4.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{dot}}\mathsf{\_i16x8\_s} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c) \\
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & (i_1~i_2)^\ast = \href{../exec/numerics.html#op-imul}{\mathrm{imul}}_{32}(\href{../exec/numerics.html#op-extend-s}{\mathrm{extend}^{\mathsf{s}}}_{16,32}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i16x8}}}(c_1)), \href{../exec/numerics.html#op-extend-s}{\mathrm{extend}^{\mathsf{s}}}_{16,32}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i16x8}}}(c_2))) \\
\wedge & j^\ast = \href{../exec/numerics.html#op-iadd}{\mathrm{iadd}}_{32}(i_1, i_2)^\ast \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i32x4}}}(j^\ast))
\end{array}
\end{array}\end{split}\]
\(t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{extmul}}\mathsf{\_}\href{../syntax/instructions.html#syntax-half}{\mathit{half}}\mathsf{\_}t_1\mathsf{x}M\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}\)
Assert: due to syntax, \(N = M / 2\).
Assert: due to validation, two values of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) are on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2\) from the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i_1^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)\).
Let \(i_2^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_2)\).
If \(\href{../syntax/instructions.html#syntax-half}{\mathit{half}}\) is \(\mathsf{low}\), then:
Let \(j_1^\ast\) be the sequence \(i_1^\ast[0 \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N]\).
Let \(j_2^\ast\) be the sequence \(i_2^\ast[0 \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N]\).
Else:
Let \(j_1^\ast\) be the sequence \(i_1^\ast[N \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N]\).
Let \(j_2^\ast\) be the sequence \(i_2^\ast[N \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N]\).
Let \(k_1^\ast\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(j_1^\ast)\).
Let \(k_2^\ast\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(j_2^\ast)\).
Let \(k^\ast\) be the result of computing \(\href{../exec/numerics.html#op-imul}{\mathrm{imul}}_{t_2\mathsf{x}N}(k_1^\ast, k_2^\ast)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(k^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) onto the stack.
\[\begin{split}\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_2)~t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{extmul}}\mathsf{\_}\href{../syntax/instructions.html#syntax-half}{\mathit{half}}\mathsf{\_}t_1\mathsf{x}M\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c) \\
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & i^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)[\href{../syntax/instructions.html#syntax-half}{\mathit{half}}(0, N) \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N] \\
\wedge & j^\ast = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_2)[\href{../syntax/instructions.html#syntax-half}{\mathit{half}}(0, N) \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N] \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(\href{../exec/numerics.html#op-imul}{\mathrm{imul}}_{t_2\mathsf{x}N}(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(i^\ast), \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(j^\ast))))
\end{array}\end{split}\]
where:
\[\begin{split}\begin{array}{lcl}
\mathsf{low}(x, y) &=& x \\
\mathsf{high}(x, y) &=& y \\
\end{array}\end{split}\]
\(t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{extadd\_pairwise}}\_t_1\mathsf{x}M\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}\)
Assert: due to syntax, \(N = M / 2\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1\) from the stack.
Let \(i^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)\).
Let \((j_1~j_2)^\ast\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(i^\ast)\).
Let \(k^\ast\) be the result of computing \(\href{../exec/numerics.html#op-iadd}{\mathrm{iadd}}_{N}(j_1, j_2)^\ast\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(k^\ast)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c_1)~t_2\mathsf{x}N\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{extadd\_pairwise}}\_t_1\mathsf{x}M\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c) \\
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & (i_1~i_2)^\ast = \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{|t_1|,|t_2|}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{t_1\mathsf{x}M}(c_1)) \\
\wedge & j^\ast = \href{../exec/numerics.html#op-iadd}{\mathrm{iadd}}_{N}(i_1, i_2)^\ast \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{t_2\mathsf{x}N}(j^\ast))
\end{array}
\end{array}\end{split}\]
Table Instructions
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(a\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\) exists.
Let \(\mathit{tab}\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
If \(i\) is not smaller than the length of \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\), then:
Trap.
Let \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) be the value \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}[i]\).
Push the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-val}{\mathit{val}}
\end{array}
\\ \qquad
(\mathrel{\mbox{if}} S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}[i] = \href{../exec/runtime.html#syntax-val}{\mathit{val}}) \\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(a\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\) exists.
Let \(\mathit{tab}\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\).
Assert: due to validation, a reference value is on the top of the stack.
Pop the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
If \(i\) is not smaller than the length of \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\), then:
Trap.
Replace the element \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}[i]\) with \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; \epsilon
\end{array}
\\ \qquad
(\mathrel{\mbox{if}} S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}[i] = \href{../exec/runtime.html#syntax-val}{\mathit{val}}) \\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.size}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(a\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\) exists.
Let \(\mathit{tab}\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\).
Let \(\mathit{sz}\) be the length of \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz}\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.size}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz})
\end{array}
\\ \qquad
(\mathrel{\mbox{if}} |S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}| = \mathit{sz}) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.grow}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(a\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\) exists.
Let \(\mathit{tab}\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\).
Let \(\mathit{sz}\) be the length of \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Assert: due to validation, a reference value is on the top of the stack.
Pop the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) from the stack.
Let \(\mathit{err}\) be the \(\href{../syntax/values.html#syntax-int}{\mathit{i32}}\) value \(2^{32}-1\), for which \(\href{../exec/numerics.html#aux-signed}{\mathrm{signed}}_{32}(\mathit{err})\) is \(-1\).
Either:
If growing \(\mathit{tab}\) by \(n\) entries with initialization value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) succeeds, then:
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz}\) to the stack.
Else:
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{err}\) to the stack.
Or:
push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{err}\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; \href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.grow}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz})
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x] = a \\
\wedge & \mathit{sz} = |S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}| \\
\wedge & S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a] = \href{../exec/modules.html#grow-table}{\mathrm{growtable}}(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[a], n, \href{../exec/runtime.html#syntax-val}{\mathit{val}})) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; \href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.grow}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\href{../exec/numerics.html#aux-signed}{\mathrm{signed}}_{32}^{-1}(-1))
\end{array}
\end{array}\end{split}\]
Note
The \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.grow}}\) instruction is non-deterministic.
It may either succeed, returning the old table size \(\mathit{sz}\),
or fail, returning \({-1}\).
Failure must occur if the referenced table instance has a maximum size defined that would be exceeded.
However, failure can occur in other cases as well.
In practice, the choice depends on the resources available to the embedder.
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.fill}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(\mathit{ta}\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}]\) exists.
Let \(\mathit{tab}\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Assert: due to validation, a reference value is on the top of the stack.
Pop the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
If \(i + n\) is larger than the length of \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\), then:
Trap.
If \(n\) is \(0\), then:
Return.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) to the stack.
Push the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(i+1)\) to the stack.
Push the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(n-1)\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.fill}}~x\).
\[\begin{split}\begin{array}{l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.fill}}~x)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}\quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & i + n > |S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}|) \\[1ex]
\end{array}
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.fill}}~x)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}\quad S; F; \epsilon
\\ \qquad
(\mathrel{\mbox{otherwise}})
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.fill}}~x)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i+1)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.fill}}~x) \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(\mathit{ta}_x\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}_x]\) exists.
Let \(\mathit{tab}_x\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}_x]\).
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[y]\) exists.
Let \(\mathit{ta}_y\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[y]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}_y]\) exists.
Let \(\mathit{tab}_y\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}_y]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) from the stack.
If \(s + n\) is larger than the length of \(\mathit{tab}_y.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\) or \(d + n\) is larger than the length of \(\mathit{tab}_x.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\), then:
Trap.
If \(n = 0\), then:
If \(d \leq s\), then:
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~y\).
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x\).
Assert: due to the earlier check against the table size, \(d+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(d+1)\) to the stack.
Assert: due to the earlier check against the table size, \(s+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(s+1)\) to the stack.
Else:
Assert: due to the earlier check against the table size, \(d+n-1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(d+n-1)\) to the stack.
Assert: due to the earlier check against the table size, \(s+n-1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(s+n-1)\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~y\).
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(n-1)\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}\quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & s + n > |S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[y]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}| \\
\vee & d + n > |S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}|) \\[1ex]
\end{array}
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}\quad S; F; \epsilon
\\ \qquad
(\mathrel{\mbox{otherwise}})
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~y)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y) \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} d \leq s)
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d+n)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s+n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~y)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.copy}}~x~y) \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} d > s) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.init}}~x~y\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(\mathit{ta}\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}]\) exists.
Let \(\mathit{tab}\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}]\).
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{elemaddrs}}[y]\) exists.
Let \(\mathit{ea}\) be the element address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{elemaddrs}}[y]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{elems}}[\mathit{ea}]\) exists.
Let \(\mathit{elem}\) be the element instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{elems}}[\mathit{ea}]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) from the stack.
If \(s + n\) is larger than the length of \(\mathit{elem}.\href{../exec/runtime.html#syntax-eleminst}{\mathsf{elem}}\) or \(d + n\) is larger than the length of \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\), then:
Trap.
If \(n = 0\), then:
Return.
Let \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) be the reference value \(\mathit{elem}.\href{../exec/runtime.html#syntax-eleminst}{\mathsf{elem}}[s]\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) to the stack.
Push the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x\).
Assert: due to the earlier check against the table size, \(d+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(d+1)\) to the stack.
Assert: due to the earlier check against the segment size, \(s+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(s+1)\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(n-1)\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.init}}~x~y\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.init}}~x~y)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}\quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & s + n > |S.\href{../exec/runtime.html#syntax-store}{\mathsf{elems}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{elemaddrs}}[y]].\href{../exec/runtime.html#syntax-eleminst}{\mathsf{elem}}| \\
\vee & d + n > |S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}|) \\[1ex]
\end{array}
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.init}}~x~y)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}\quad S; F; \epsilon
\\ \qquad
(\mathrel{\mbox{otherwise}})
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.init}}~x~y)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.set}}~x) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table.init}}~x~y) \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \href{../exec/runtime.html#syntax-val}{\mathit{val}} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{elems}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{elemaddrs}}[y]].\href{../exec/runtime.html#syntax-eleminst}{\mathsf{elem}}[s]) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{elem.drop}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{elemaddrs}}[x]\) exists.
Let \(a\) be the element address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{elemaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{elems}}[a]\) exists.
Replace \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{elems}}[a].\href{../exec/runtime.html#syntax-eleminst}{\mathsf{elem}}\) with \(\epsilon\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{elem.drop}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; \epsilon
\end{array}
\\ \qquad
(\mathrel{\mbox{if}} S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{elems}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{elemaddrs}}[x]].\href{../exec/runtime.html#syntax-eleminst}{\mathsf{elem}} = \epsilon) \\
\end{array}\end{split}\]
Memory Instructions
Note
The alignment \(\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}\) in load and store instructions does not affect the semantics.
It is an indication that the offset \(\mathit{ea}\) at which the memory is accessed is intended to satisfy the property \(\mathit{ea} \mathbin{\mathrm{mod}} 2^{\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}} = 0\).
A WebAssembly implementation can use this hint to optimize for the intended use.
Unaligned access violating that property is still allowed and must succeed regardless of the annotation.
However, it may be substantially slower on some hardware.
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\) and \(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) be \(\href{../exec/runtime.html#syntax-ord}{\mathsf{unord}}\).
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be the integer \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(N\) is not part of the instruction, then:
If both \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) is \(\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}\) and \(\mathit{ea}\) modulo \(N/8\) is not equal to \(0\), then:
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Let \(b^\ast\) be the byte sequence \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{notears}}^?\) be \(\href{../exec/relaxed.html#syntax-ord}{\mathrm{tearing}}(t, N, \mathit{ea})\).
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast~\href{../exec/runtime.html#syntax-ord}{\mathit{notears}}^?)\) to read \(N/8\) bytes \(b^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Let \(c_{N}\) be the integer for which \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b^\ast\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{N,|t|}(c_{N})\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}({N}\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}})^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & (\href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0) \\
\wedge & c = \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{N,|t|}(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}^{-1}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}({N}\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}})^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}({N}\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}})?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast~\href{../exec/runtime.html#syntax-ord}{\mathit{notears}}^?)}&
S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & (\href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0) \\
\wedge & c = \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{N,|t|}(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}^{-1}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(b^\ast))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}({N}\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}})^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n \vee \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}} \wedge \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0)) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \\
\wedge & N = |t| \mathrel{\mbox{if}} N~\mbox{not present} \\
\wedge & \mathit{sx} = \mathsf{u} \mathrel{\mbox{if}} \mathit{sx}~\mbox{not present} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} \\
\wedge & \href{../exec/runtime.html#syntax-ord}{\mathit{notears}}^? = \href{../exec/relaxed.html#syntax-ord}{\mathrm{tearing}}(t, N, \mathit{ea})) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{M}\mathsf{x}N\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) be \(\href{../exec/runtime.html#syntax-ord}{\mathsf{unord}}\).
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be the integer \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + M \cdot N /8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Let \(b^\ast\) be the byte sequence \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} M \cdot N /8]\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + M \cdot N/8\) is larger than \(n\), then:
Trap.
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)\) to read \(M \cdot N/8\) bytes \(b^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Let \(m_k\) be the integer for which \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}M}}(m_k) = b^\ast[k \cdot M/8 \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} M/8]\).
Let \(W\) be the integer \(M \cdot 2\).
Let \(n_k\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{M,W}(m_k)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\mathsf{i}W\mathsf{x}N}(n_0 \dots n_{N-1})\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{M}\mathsf{x}N\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + M \cdot N / 8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}M}}(m_k) = \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} + k \cdot M/8 \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} M/8] \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\mathsf{i}W\mathsf{x}N}(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{M,W}(m_0) \dots \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{M,W}(m_{N-1}))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{M}\mathsf{x}N\mathsf{\_}\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{M}\mathsf{x}N\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)}&
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + M \cdot N / 8 \leq n \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}M}}(m_k) = b^\ast[k \cdot M/8 \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} M/8] \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\mathsf{i}W\mathsf{x}N}(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{M,W}(m_0) \dots \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}_{M,W}(m_{N-1}))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{M}\mathsf{x}N\_\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + M \cdot N/8 > n) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} \\
\wedge & W = M \cdot 2) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_splat}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) be \(\href{../exec/runtime.html#syntax-ord}{\mathsf{unord}}\).
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be the integer \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Let \(b^\ast\) be the byte sequence \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)\) to read \(N/8\) bytes \(b^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Let \(n\) be the integer for which \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b^\ast\).
Let \(L\) be the integer \(128 / N\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(n^L)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_splat}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8] \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(n^L)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_splat}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_splat}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)}&
S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b^\ast \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(n^L)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_splat}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_zero}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) be \(\href{../exec/runtime.html#syntax-ord}{\mathsf{unord}}\).
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be the integer \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Let \(b^\ast\) be the byte sequence \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)\) to read \(N/8\) bytes \(b^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Let \(n\) be the integer for which \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b^\ast\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}^{\mathsf{u}}}_{N,128}(n)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_zero}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8] \\
\wedge & c = \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}^{\mathsf{u}}}_{N,128}(n)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_zero}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_zero}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)}&
S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b^\ast \\
\wedge & c = \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}^{\mathsf{u}}}_{N,128}(n)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_zero}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x\)
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) be \(\href{../exec/runtime.html#syntax-ord}{\mathsf{unord}}\).
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~v\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be the integer \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Let \(b^\ast\) be the byte sequence \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)\) to read \(N/8\) bytes \(b^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Let \(r\) be the constant for which \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(r) = b^\ast\).
Let \(L\) be \(128 / N\).
Let \(j^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(v)\).
Let \(c\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(j^\ast \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} [x] = r)\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~v)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8] \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(v) \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} [x] = r)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~v)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~v)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x)
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)}&
S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b^\ast \\
\wedge & c = \href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}^{-1}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(v) \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} [x] = r)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~v)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x)
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}) \\
\wedge & L = 128/N \\
\end{array}
\end{array}\end{split}\]
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\) and \(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}{N}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) be \(\href{../exec/runtime.html#syntax-ord}{\mathsf{unord}}\).
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(t\) is on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be the integer \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(N\) is not part of the instruction, then:
Let \(N\) be the bit width \(|t|\) of number type \(t\).
If both \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) is \(\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}\) and \(\mathit{ea}\) modulo \(N/8\) is not equal to \(0\), then:
Let \(n\) be the result of computing \(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c)\).
Let \(b^\ast\) be the byte sequence \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n)\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Replace the bytes \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\) with \(b^\ast\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{notears}}^?\) be \(\href{../exec/relaxed.html#syntax-ord}{\mathrm{tearing}}(t, N, \mathit{ea})\).
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{wr}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast~\href{../exec/runtime.html#syntax-ord}{\mathit{notears}}^?)\) to write the bytes \(b^\ast\) to data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}} N^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; \epsilon
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & (\href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0) \\
\wedge & S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]].\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8] = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}} N^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}} N^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{wr}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)~\href{../exec/runtime.html#syntax-ord}{\mathit{notears}}}&
S; F; \epsilon
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & (\href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0) \\
\wedge & b^\ast = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(t.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}} N^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n \vee \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}} \wedge \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0)) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \\
\wedge & N = |t| \mathrel{\mbox{if}} N~\mbox{not present} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} \\
\wedge & \href{../exec/runtime.html#syntax-ord}{\mathit{notears}}^? = \href{../exec/relaxed.html#syntax-ord}{\mathrm{tearing}}(t, N, \mathit{ea})) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x\)
Let \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}\) be \(\href{../exec/runtime.html#syntax-ord}{\mathsf{unord}}\).
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be the integer \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
Let \(L\) be \(128/N\).
Let \(j^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(c)\).
Let \(b^\ast\) be the result of computing \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(j^\ast[x])\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Replace the bytes \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\) with \(b^\ast\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{wr}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)\) to write the bytes \(b^\ast\) to data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; \epsilon
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]].\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8] = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(c)[x])) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x)
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{wr}}_{\href{../exec/runtime.html#syntax-ord}{\mathit{ord}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)}&
S; F; \epsilon
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & b^\ast = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}_{\href{../syntax/types.html#syntax-valtype}{\mathsf{i}N}\mathsf{x}L}(c)[x])) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{v128}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}{N}\mathsf{\_lane}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}~x)
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n \vee \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}} \wedge \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0)) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & \href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{unord}} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} \\
\wedge & L = 128/N) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.size}}\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
Let \(n\) be the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
Let \(\mathit{sz}\) be \(n\) divided by the page size.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz}\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.size}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz})
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| = \mathit{sz}\cdot64\,\mathrm{Ki}
\end{array}
\\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.size}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz})
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & n = \mathit{sz} \cdot 64\,\mathrm{Ki}) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.grow}}\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Let \(\mathit{err}\) be the \(\href{../syntax/values.html#syntax-int}{\mathit{i32}}\) value \(2^{32}-1\), for which \(\href{../exec/numerics.html#aux-signed}{\mathrm{signed}}_{32}(\mathit{err})\) is \(-1\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
Let \(\mathit{sz}\) be the length of \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\) divided by the page size.
Either, try growing \(\mathit{mem}\) by \(n\) pages:
If it succeeds, push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz}\) to the stack.
Else, push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{err}\) to the stack.
Or, push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{err}\) to the stack.
Else:
Either successfully grow the memory:
Let \(k\) be \(n\) multiplied by the page size.
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rmw}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l~(l+k))\) to update the current length \(l\) of the shared memory instance at memory address \(a\) to \(l+k\).
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{wr}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[l]~(0)^k)\) to append \(k\) zero bytes to the end of the shared memory instance at memory address \(a\).
Let \(\mathit{sz}\) be \(l\) divided by the page size.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz}\) to the stack.
Or indicate failure:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l)\) to read the length \(l\) of the shared memory instance at memory address \(a\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{err}\) to the stack.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.grow}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz})
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{sz} = |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| / 64\,\mathrm{Ki} \\
\wedge & S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] = \href{../exec/modules.html#grow-mem}{\mathrm{growmem}}(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a], n)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.grow}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\href{../exec/numerics.html#aux-signed}{\mathrm{signed}}_{32}^{-1}(-1))
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
\end{array}
\\
%
\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.grow}}
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rmw}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l~(l+k))~(\href{../exec/runtime.html#syntax-act}{\mathsf{wr}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[l]~(0)^k)}&
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~\mathit{sz})
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{sz} = l / 64\,\mathrm{Ki} \\
\wedge & n = k / 64\,\mathrm{Ki}) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.grow}}
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{-1})
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}}) \\
\end{array}
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]) \\
\end{array}
\end{array}\end{split}\]
Note
The \(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.grow}}\) instruction is non-deterministic, even on unshared memories.
It may either succeed, returning the old memory size \(\mathit{sz}\),
or fail, returning \({-1}\).
Failure must occur if the referenced memory instance has a maximum size defined that would be exceeded.
However, failure can occur in other cases as well.
In practice, the choice depends on the resources available to the embedder.
\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.fill}}\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(\mathit{ma}\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{ma}]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{ma}]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) from the stack.
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(d + n\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l)\) to read the length \(l\) of the shared memory instance at memory address \(a\).
If \(d + n\) is larger than \(l\), then:
Trap.
If \(n = 0\), then:
Return.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) to the stack.
Push the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) to the stack.
Execute the instruction \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}\).
Assert: due to the earlier check against the memory size, \(d+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(d+1)\) to the stack.
Push the value \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(n-1)\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.fill}}\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.fill}}
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act} \quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & d + n > l
\end{array}
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.fill}}
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act} \quad S; F; \epsilon
\\ \qquad
(\mathrel{\mbox{otherwise}}) \\
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.fill}}
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d+1)~\href{../exec/runtime.html#syntax-val}{\mathit{val}}~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.fill}} \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}) \\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & ((\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \wedge l = |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \wedge \mathit{act} = \epsilon) \vee (\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \wedge \mathit{act} = (\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l))) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}}\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(\mathit{ma}\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{ma}]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{ma}]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) from the stack.
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(s + n\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\) or \(d + n\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l)\) to read the length \(l\) of the shared memory instance at memory address \(a\).
If \(s + n\) is larger than \(l\) or \(d + n\) is larger than \(l\), then:
Trap.
If \(n = 0\), then:
If \(d \leq s\), then:
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) to the stack.
Execute the instruction \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{8\_u}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}\).
Execute the instruction \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}\).
Assert: due to the earlier check against the memory size, \(d+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(d+1)\) to the stack.
Assert: due to the earlier check against the memory size, \(s+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(s+1)\) to the stack.
Else:
Assert: due to the earlier check against the memory size, \(d+n-1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(d+n-1)\) to the stack.
Assert: due to the earlier check against the memory size, \(s+n-1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(s+n-1)\) to the stack.
Execute the instruction \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{8\_u}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}\).
Execute the instruction \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(n-1)\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}}\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}}
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act}\quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & (s + n > l \\
\vee & d + n > l)) \\[1ex]
\end{array}
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}}
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}\quad S; F; \epsilon
\\ \qquad
(\mathrel{\mbox{otherwise}})
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}}
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{8\_u}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}} \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}})
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}}
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d+n) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s+n)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{8\_u}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}} \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}})
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & ((\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \wedge l = |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \wedge \mathit{act} = \epsilon) \vee (\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \wedge \mathit{act} = (\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l))) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.init}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(\mathit{ma}\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{ma}]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{ma}]\).
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{dataaddrs}}[x]\) exists.
Let \(\mathit{da}\) be the data address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{dataaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{datas}}[\mathit{da}]\) exists.
Let \(\mathit{data}\) be the data instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{datas}}[\mathit{da}]\).
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) from the stack.
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(s + n\) is larger than the length of \(\mathit{data}.\href{../exec/runtime.html#syntax-datainst}{\mathsf{data}}\) or \(d + n\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l)\) to read the length \(l\) of the shared memory instance at memory address \(a\).
If \(s + n\) is larger than the length of \(\mathit{data}.\href{../exec/runtime.html#syntax-datainst}{\mathsf{data}}\) or \(d + n\) is larger than \(l\), then:
Trap.
If \(n = 0\), then:
Return.
Let \(b\) be the byte \(\mathit{data}.\href{../exec/runtime.html#syntax-datainst}{\mathsf{data}}[s]\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~b\) to the stack.
Execute the instruction \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}\).
Assert: due to the earlier check against the memory size, \(d+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(d+1)\) to the stack.
Assert: due to the earlier check against the memory size, \(s+1 < 2^{32}\).
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(s+1)\) to the stack.
Push the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(n-1)\) to the stack.
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.init}}~x\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.init}}~x)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act}\quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & (s + n > |S.\href{../exec/runtime.html#syntax-store}{\mathsf{datas}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{dataaddrs}}[x]].\href{../exec/runtime.html#syntax-datainst}{\mathsf{data}}| \\
\vee & d + n > l)) \\[1ex]
\end{array}
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)~(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.init}}~x)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act}\quad S; F; \epsilon
\\ \qquad
(\mathrel{\mbox{otherwise}})
\\[1ex]
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n+1)~(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.init}}~x)
\quad\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^\mathit{act}
\\ \qquad S; F;
\begin{array}[t]{@{}l@{}}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~b)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~\{ \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}~0, \href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~0 \}) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~d+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~s+1)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)~(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.init}}~x) \\
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}}, \mathrel{\mbox{if}} b = S.\href{../exec/runtime.html#syntax-store}{\mathsf{datas}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{dataaddrs}}[x]].\href{../exec/runtime.html#syntax-datainst}{\mathsf{data}}[s])
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & ((\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \wedge l = |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \wedge \mathit{act} = \epsilon) \vee (\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \wedge \mathit{act} = (\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~l))) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{data.drop}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{dataaddrs}}[x]\) exists.
Let \(a\) be the data address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{dataaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{datas}}[a]\) exists.
Replace \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{datas}}[a]\) with the data instance \(\{\href{../exec/runtime.html#syntax-datainst}{\mathsf{data}}~\epsilon\}\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{data.drop}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; \epsilon
\end{array}
\\ \qquad
(\mathrel{\mbox{if}} S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{datas}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{dataaddrs}}[x]] = \{ \href{../exec/runtime.html#syntax-datainst}{\mathsf{data}}~\epsilon \}) \\
\end{array}\end{split}\]
Atomic Memory Instructions
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.load}}({N}\mathsf{\_u})^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
The rules are identical to non-atomic loads, except that \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}\).
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.store}}{N}^?~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
The rules are identical to non-atomic stores, except that \(\href{../exec/runtime.html#syntax-ord}{\mathit{ord}} = \href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}\).
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?\mathsf{.}\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
If \(N\) is not part of the instruction, then:
Let \(N\) be the bit width \(|t|\) of value type \(t\).
Assert: due to validation, a value of value type \(t\) is on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{ea}\) modulo \(N/8\) is not equal to \(0\), then:
Trap.
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(\mathit{a}\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{a}]\) exists.
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[\mathit{a}]\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Let \(b^\ast_{\mathrm{r}}\) be the byte sequence \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Let \(b_{\mathrm{r}}^\ast\) be chosen to represent \(N/8\) bytes of memory at location \(\mathit{ea}\) of \(\mathit{mem}\).
Let \(c_{\mathrm{r}}\) be the integer for which \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b_{\mathrm{r}}^\ast\).
Let \(c_1\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\mathsf{u}}_{N,|t|}(c_{\mathrm{r}})\).
Let \(c\) be the result of computing \(\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}_t(c_1, c_2)\).
Let \(c_{\mathrm{w}}\) be the result of computing \(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c)\).
Let \(b^\ast_{\mathrm{w}}\) be the byte sequence \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(c_{\mathrm{w}})\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
Replace the bytes \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\) with \(b^\ast_{\mathrm{w}}\).
Else:
Perform the atomic action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rmw}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b_{\mathrm{r}}^\ast~b_{\mathrm{w}}^\ast)\) to read \(N/8\) bytes \(b_{\mathrm{r}}^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\) and replace them with bytes \(b_{\mathrm{w}}^\ast\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
S'; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0 \\
\wedge & c_1 = \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\mathsf{u}}_{N,|t|}(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}^{-1}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8])) \\
\wedge & S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a].\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8] = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}_t(c_1, c_2)))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 > |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0) \\
\end{array}
\\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rmw}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b_{\mathrm{r}}^\ast~b_{\mathrm{w}}^\ast)}&
S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0 \\
\wedge & c_1 = \href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\mathsf{u}}_{N,|t|}(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}^{-1}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(b_{\mathrm{r}}^\ast)) \\
\wedge & b_{\mathrm{w}}^\ast = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}_t(c_1, c_2)))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-atop}{\mathit{atop}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 > n \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & N = |t| \mathrel{\mbox{if}} N~\mbox{not present} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}) \\
\end{array}
\end{array}\end{split}\]
\(t\mathsf{.}\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?\mathsf{.}\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{cmpxchg}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
If \(N\) is not part of the instruction, then:
Let \(N\) be the bit width \(|t|\) of value type \(t\).
Assert: due to validation, two values of value type \(t\) are on the top of the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3\) from the stack.
Pop the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{ea}\) modulo \(N/8\) is not equal to \(0\), then:
Trap.
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Let \(b^\ast_{\mathrm{r}}\) be the byte sequence \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\).
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Let \(b_{\mathrm{r}}^\ast\) be chosen to represent \(N/8\) bytes of memory at location \(\mathit{ea}\) of \(\mathit{mem}\).
Let \(c_{\mathrm{r}}\) be the integer for which \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(n) = b_{\mathrm{r}}^\ast\).
Let \(c_{\mathrm{ex}}\) be the result of computing \(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c_2)\).
If \(c_{\mathrm{r}}\) equals \(c_{\mathrm{ex}}\), then:
Let \(c_{\mathrm{w}}\) be the result of computing \(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c_3)\).
Let \(b^\ast_{\mathrm{w}}\) be the byte sequence \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(c_{\mathrm{w}})\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
Replace the bytes \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]\) with \(b^\ast_{\mathrm{w}}\).
Else:
Perform the atomic action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rmw}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b_{\mathrm{r}}^\ast~b_{\mathrm{w}}^\ast)\) to read \(N/8\) bytes \(b_{\mathrm{r}}^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\) and replace them with bytes \(b_{\mathrm{w}}^\ast\).
Else:
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}}\), then:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b_{\mathrm{r}}^\ast)\) to read \(N/8\) bytes \(b_{\mathrm{r}}^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Let \(c_1\) be the result of computing \(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\mathsf{u}}_{N,|t|}(c_{\mathrm{r}})\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{cmpxchg}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
S'; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~(\href{../exec/numerics.html#op-extend-u}{\mathrm{extend}}^{\mathsf{u}}_{N,|t|}(c_{\mathrm{r}})))
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0 \\
\wedge & c_{\mathrm{r}} = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}^{-1}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8]) \\
\wedge & c_{\mathrm{ex}} = \href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c_2) \\
\wedge & ((c_{\mathrm{r}} = c_{\mathrm{ex}} \wedge c = \href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c_3)) \vee (c_{\mathrm{r}} \neq c_{\mathrm{ex}} \wedge c = c_{\mathrm{r}})) \\
\wedge & S' = S \href{../syntax/conventions.html#notation-replace}{\mathrel{\mbox{with}}} \href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a].\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}[\mathit{ea} \href{../syntax/conventions.html#notation-slice}{\mathrel{\mathbf{:}}} N/8] = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(c)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{cmpxchg}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 > |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0) \\
\end{array}
\\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{cmpxchg}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rmw}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b_{\mathrm{r}}^\ast~b_{\mathrm{w}}^\ast)}&
S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0 \\
\wedge & c_{\mathrm{r}} = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}^{-1}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(b_{\mathrm{r}}^\ast) \\
\wedge & c_{\mathrm{ex}} = \href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c_2) \\
\wedge & c_{\mathrm{r}} = c_{\mathrm{ex}} \\
\wedge & b_{\mathrm{w}}^\ast = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c_3))) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{cmpxchg}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b_{\mathrm{r}}^\ast)}&
S; F; (t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0 \\
\wedge & c_{\mathrm{r}} = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}^{-1}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(b_{\mathrm{r}}^\ast) \\
\wedge & c_{\mathrm{ex}} = \href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}_{|t|,N}(c_2) \\
\wedge & c_{\mathrm{r}} \neq c_{\mathrm{ex}} \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)~(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)~(t.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.rmw}}({N}\mathsf{\_u})^?.\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{cmpxchg}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}})
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 > n \vee \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & N = |t| \mathrel{\mbox{if}} N~\mbox{not present} \\
\wedge & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.notify}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
Let \(N\) be 32.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{ea}\) modulo \(N/8\) is not equal to \(0\), then:
Trap.
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
If \(\mathit{ea} + N/8\) is larger than the length of \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}\), then:
Trap.
Else:
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0\) to the stack.
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{notify}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~n~k)\) to notify \(n\) threads (up to \(k\)) waiting at data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.notify}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & \mathit{ea} + N/8 \leq |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.notify}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}} \\
\wedge & (\mathit{ea} + N/8 > |\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{data}}| ~\vee~ \mathit{ea} \mathbin{\mathrm{mod}}~N/8 \neq 0)) \\
\end{array}
\\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.notify}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}} && \\
\qquad\qquad \href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{notify}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~j~k)}
\quad S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j) &&
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & j \leq k \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.notify}}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}
&\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}&
S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n ~\vee~ \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0)) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} \\
\wedge & N = 32) \\
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.wait}}{N}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/values.html#syntax-int}{\mathit{i}N}\) is on the top of the stack.
Pop the value \(\href{../syntax/values.html#syntax-int}{\mathit{i}N}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) from the stack.
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
Let \(\mathit{ea}\) be \(i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}\).
If \(\mathit{ea}\) modulo \(N/8\) is not equal to \(0\), then:
Trap.
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\) exists.
Let \(a\) be the memory address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0]\).
Let \(\mathit{mem}\) be the memory instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a]\).
If \(\mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\) is \(\href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}\), then:
Trap.
Else:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)\) to read the length \(n\) of the shared memory instance at memory address \(a\).
If \(\mathit{ea} + N/8\) is larger than \(n\), then:
Trap.
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)\) to read \(N/8\) bytes \(b^\ast\) from data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
If \(\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(c)\) is equal to \(b^\ast\) then:
Let \(t\) be \(\href{../exec/numerics.html#aux-signed}{\mathrm{signed}}_{N}(k)\).
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{wait}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~t)\) to register the current thread as waiting for a signal at data offset \(\mathit{ea}\) of the shared memory instance at memory address \(a\).
Execute the instruction \(\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{wait'}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~k\).
Else:
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~1\) to the stack.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/values.html#syntax-int}{\mathit{i}N}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.wait}}{N}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}} && \\
\qquad\qquad \href{../exec/conventions.html#formal-notation}{\hookrightarrow} \quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}} &&
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{unshared}}) \\
\end{array}
\\
%
~\\
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/values.html#syntax-int}{\mathit{i}N}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.wait}}{N}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}} &&\\
\qquad\qquad \href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)~(\href{../exec/runtime.html#syntax-act}{\mathsf{wait}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~t)}
\quad S; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{wait'}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~k) && \\
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0 \\
\wedge & b^\ast = \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(c))\\
\wedge & t = \href{../exec/numerics.html#aux-signed}{\mathrm{signed}}_{N}(k) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/values.html#syntax-int}{\mathit{i}N}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.wait}}{N}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}} &&\\
\qquad\qquad \href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)~(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{data}}[\mathit{ea}]~b^\ast)}
\quad S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~1)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & \mathit{ea} + N/8 \leq n \\
\wedge & \mathit{ea} \mathbin{\mathrm{mod}} N/8 = 0 \\
\wedge & b^\ast \neq \href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}_{\href{../syntax/values.html#syntax-int}{\mathit{i}N}}(c)) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/values.html#syntax-int}{\mathit{i}N}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~k)~\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{memory.atomic.wait}}{N}~\href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}} &&\\
\qquad\qquad \href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{rd}}~a.\href{../exec/runtime.html#syntax-loc}{\mathsf{len}}~n)}
\quad S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \mathit{mem}.\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}} = \href{../syntax/types.html#syntax-limits}{\mathit{limits}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{shared}} \\
\wedge & (\mathit{ea} + N/8 > n ~\vee~ \mathit{ea} \mathbin{\mathrm{mod}} N/8 \neq 0)) \\
\end{array}
\\
%
~\\
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{where}} & a = F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{memaddrs}}[0] \\
\wedge & \mathit{mem} = S.\href{../exec/runtime.html#syntax-store}{\mathsf{mems}}[a] \\
\wedge & \mathit{ea} = i + \href{../syntax/instructions.html#syntax-memarg}{\mathit{memarg}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}}) \\
\end{array}
\end{array}\end{split}\]
\(\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{wait'}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}}~n\)
Either the thread has been notified by an \((\href{../exec/runtime.html#syntax-act}{\mathsf{notify}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}})\) action performed in another thread:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{woken}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}})\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0\) to the stack.
Or:
If \(n\) is less than \(0\):
The thread remains suspended.
Else:
Either the thread’s suspension times out:
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{timeout}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}})\).
Push the value \(t.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~2\) to the stack.
Or the thread remains suspended.
\[\begin{split}\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{wait'}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}}~n &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{woken}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}})}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{wait'}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}}~n &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{timeout}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}})}& (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~2)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & n \geq 0) \\
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{wait'}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}}~n &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-instr-admin}{\mathsf{wait'}}~\href{../exec/runtime.html#syntax-loc}{\mathit{loc}}~n
\end{array}
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.fence}}\)
Perform the action \((\href{../exec/runtime.html#syntax-act}{\mathsf{fence}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}})\).
\[\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
\href{../syntax/instructions.html#syntax-instr-atomic-memory}{\mathsf{atomic.fence}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{(\href{../exec/runtime.html#syntax-act}{\mathsf{fence}}_{\href{../exec/runtime.html#syntax-ord}{\mathsf{seqcst}}})}& \epsilon
\end{array}
\end{array}\]
Control Instructions
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{nop}}\)
Do nothing.
\[\begin{array}{lcl@{\qquad}l}
\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{nop}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \epsilon
\end{array}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{unreachable}}\)
Trap.
\[\begin{array}{lcl@{\qquad}l}
\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{unreachable}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}\)
Let \(F\) be the current frame.
Assert: due to validation, \(\href{../exec/runtime.html#exec-expand}{\mathrm{expand}}_F(\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}})\) is defined.
Let \([t_1^m] \href{../syntax/types.html#syntax-functype}{\rightarrow} [t_2^n]\) be the function type \(\href{../exec/runtime.html#exec-expand}{\mathrm{expand}}_F(\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}})\).
Let \(L\) be the label whose arity is \(n\) and whose continuation is the end of the block.
Assert: due to validation, there are at least \(m\) values on the top of the stack.
Pop the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m\) from the stack.
Enter the block \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) with label \(L\).
\[\begin{split}~\\[-1ex]
\begin{array}{lcl}
F; \href{../exec/runtime.html#syntax-val}{\mathit{val}}^m~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~\mathit{bt}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
F; \href{../exec/runtime.html#syntax-label}{\mathsf{label}}_n\{\epsilon\}~\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}
\\&&\quad (\mathrel{\mbox{if}} \href{../exec/runtime.html#exec-expand}{\mathrm{expand}}_F(\mathit{bt}) = [t_1^m] \href{../syntax/types.html#syntax-functype}{\rightarrow} [t_2^n])
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{loop}}~\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}\)
Let \(F\) be the current frame.
Assert: due to validation, \(\href{../exec/runtime.html#exec-expand}{\mathrm{expand}}_F(\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}})\) is defined.
Let \([t_1^m] \href{../syntax/types.html#syntax-functype}{\rightarrow} [t_2^n]\) be the function type \(\href{../exec/runtime.html#exec-expand}{\mathrm{expand}}_F(\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}})\).
Let \(L\) be the label whose arity is \(m\) and whose continuation is the start of the loop.
Assert: due to validation, there are at least \(m\) values on the top of the stack.
Pop the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m\) from the stack.
Enter the block \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) with label \(L\).
\[\begin{split}~\\[-1ex]
\begin{array}{lcl}
F; \href{../exec/runtime.html#syntax-val}{\mathit{val}}^m~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{loop}}~\mathit{bt}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
F; \href{../exec/runtime.html#syntax-label}{\mathsf{label}}_m\{\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{loop}}~\mathit{bt}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}\}~\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}
\\&&\quad (\mathrel{\mbox{if}} \href{../exec/runtime.html#exec-expand}{\mathrm{expand}}_F(\mathit{bt}) = [t_1^m] \href{../syntax/types.html#syntax-functype}{\rightarrow} [t_2^n])
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{if}}~\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_1^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{else}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_2^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) from the stack.
If \(c\) is non-zero, then:
Execute the block instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_1^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}\).
Else:
Execute the block instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~\href{../syntax/instructions.html#syntax-blocktype}{\mathit{blocktype}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_2^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}\).
\[\begin{split}~\\[-1ex]
\begin{array}{lcl}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{if}}~\mathit{bt}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_1^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{else}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_2^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~\mathit{bt}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_1^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}
\\&&\quad (\mathrel{\mbox{if}} c \neq 0) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{if}}~\mathit{bt}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_1^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{else}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_2^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}&
\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~\mathit{bt}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}_2^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}
\\&&\quad (\mathrel{\mbox{if}} c = 0) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l\)
Assert: due to validation, the stack contains at least \(l+1\) labels.
Let \(L\) be the \(l\)-th label appearing on the stack, starting from the top and counting from zero.
Let \(n\) be the arity of \(L\).
Assert: due to validation, there are at least \(n\) values on the top of the stack.
Pop the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) from the stack.
Repeat \(l+1\) times:
While the top of the stack is a value, do:
Pop the value from the stack.
Assert: due to validation, the top of the stack now is a label.
Pop the label from the stack.
Push the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) to the stack.
Jump to the continuation of \(L\).
\[\begin{split}~\\[-1ex]
\begin{array}{lcl@{\qquad}l}
\href{../exec/runtime.html#syntax-label}{\mathsf{label}}_n\{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\}~\href{../exec/runtime.html#syntax-ctxt-block}{B}^l[\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)]~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_if}}~l\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\) from the stack.
If \(c\) is non-zero, then:
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l\).
Else:
Do nothing.
\[\begin{split}~\\[-1ex]
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_if}}~l) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)
& (\mathrel{\mbox{if}} c \neq 0) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)~(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_if}}~l) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \epsilon
& (\mathrel{\mbox{if}} c = 0) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_table}}~l^\ast~l_N\)
Assert: due to validation, a value of value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
If \(i\) is smaller than the length of \(l^\ast\), then:
Let \(l_i\) be the label \(l^\ast[i]\).
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l_i\).
Else:
Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l_N\).
\[\begin{split}~\\[-1ex]
\begin{array}{lcl@{\qquad}l}
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_table}}~l^\ast~l_N) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l_i)
& (\mathrel{\mbox{if}} l^\ast[i] = l_i) \\
(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_table}}~l^\ast~l_N) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& (\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l_N)
& (\mathrel{\mbox{if}} |l^\ast| \leq i) \\
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return}}\)
Let \(F\) be the current frame.
Let \(n\) be the arity of \(F\).
Assert: due to validation, there are at least \(n\) values on the top of the stack.
Pop the results \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) from the stack.
Assert: due to validation, the stack contains at least one frame.
While the top of the stack is not a frame, do:
Pop the top element from the stack.
Assert: the top of the stack is the frame \(F\).
Pop the frame from the stack.
Push \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) to the stack.
Jump to the instruction after the original call that pushed the frame.
\[\begin{split}~\\[-1ex]
\begin{array}{lcl@{\qquad}l}
\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}_n\{F\}~\href{../exec/runtime.html#syntax-ctxt-block}{B}^k[\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return}}]~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-val}{\mathit{val}}^n
\end{array}\end{split}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call}}~x\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcaddrs}}[x]\) exists.
Let \(a\) be the function address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcaddrs}}[x]\).
Invoke the function instance at address \(a\).
\[\begin{array}{lcl@{\qquad}l}
F; (\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call}}~x) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& F; (\href{../exec/runtime.html#syntax-invoke}{\mathsf{invoke}}~a)
& (\mathrel{\mbox{if}} F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcaddrs}}[x] = a)
\end{array}\]
\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_indirect}}~x~y\)
Let \(F\) be the current frame.
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\) exists.
Let \(\mathit{ta}\) be the table address \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]\).
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}]\) exists.
Let \(\mathit{tab}\) be the table instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[\mathit{ta}]\).
Assert: due to validation, \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{types}}[y]\) exists.
Let \(\mathit{ft}_{\mathrm{expect}}\) be the function type \(F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{types}}[y]\).
Assert: due to validation, a value with value type \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}\) is on the top of the stack.
Pop the value \(\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i\) from the stack.
If \(i\) is not smaller than the length of \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}\), then:
Trap.
Let \(r\) be the reference \(\mathit{tab}.\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}[i]\).
If \(r\) is \(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}null}}~t\), then:
Trap.
Assert: due to validation of table mutation, \(r\) is a function reference.
Let \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref}}~a\) be the function reference \(r\).
Assert: due to validation of table mutation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a]\) exists.
Let \(\mathit{f}\) be the function instance \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a]\).
Let \(\mathit{ft}_{\mathrm{actual}}\) be the function type \(\mathit{f}.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}}\).
If \(\mathit{ft}_{\mathrm{actual}}\) and \(\mathit{ft}_{\mathrm{expect}}\) differ, then:
Trap.
Invoke the function instance at address \(a\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_indirect}}~x~y) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; (\href{../exec/runtime.html#syntax-invoke}{\mathsf{invoke}}~a)
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & S.\href{../exec/runtime.html#syntax-store}{\mathsf{tables}}[F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tableaddrs}}[x]].\href{../exec/runtime.html#syntax-tableinst}{\mathsf{elem}}[i] = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref}}~a \\
\wedge & S.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a] = f \\
\wedge & F.\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}.\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{types}}[y] = f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}})
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)~(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_indirect}}~x~y) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\\ \qquad
(\mathrel{\mbox{otherwise}})
\end{array}\end{split}\]
Function Calls
The following auxiliary rules define the semantics of invoking a function instance
through one of the call instructions
and returning from it.
Assert: due to validation, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a]\) exists.
Let \(f\) be the function instance, \(S.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a]\).
Let \([t_1^n] \href{../syntax/types.html#syntax-functype}{\rightarrow} [t_2^m]\) be the function type \(f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}}\).
Let \(t^\ast\) be the list of value types \(f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{code}}.\href{../syntax/modules.html#syntax-func}{\mathsf{locals}}\).
Let \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}\) be the expression \(f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{code}}.\href{../syntax/modules.html#syntax-func}{\mathsf{body}}\).
Assert: due to validation, \(n\) values are on the top of the stack.
Pop the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) from the stack.
Let \(F\) be the frame \(\{ \href{../exec/runtime.html#syntax-frame}{\mathsf{module}}~f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{module}}, \href{../exec/runtime.html#syntax-frame}{\mathsf{locals}}~\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~(\href{../exec/runtime.html#default-val}{\mathrm{default}}_t)^\ast \}\).
Push the activation of \(F\) with arity \(m\) to the stack.
Let \(L\) be the label whose arity is \(m\) and whose continuation is the end of the function.
Enter the instruction sequence \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) with label \(L\).
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; \href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~(\href{../exec/runtime.html#syntax-invoke}{\mathsf{invoke}}~a) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; \href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}_m\{F\}~\href{../exec/runtime.html#syntax-label}{\mathsf{label}}_m\{\}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}}
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & S.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a] = f \\
\wedge & f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}} = [t_1^n] \href{../syntax/types.html#syntax-functype}{\rightarrow} [t_2^m] \\
\wedge & f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{code}} = \{ \href{../syntax/modules.html#syntax-func}{\mathsf{type}}~x, \href{../syntax/modules.html#syntax-func}{\mathsf{locals}}~t^k, \href{../syntax/modules.html#syntax-func}{\mathsf{body}}~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} \} \\
\wedge & F = \{ \href{../exec/runtime.html#syntax-frame}{\mathsf{module}}~f.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{module}}, ~\href{../exec/runtime.html#syntax-frame}{\mathsf{locals}}~\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~(\href{../exec/runtime.html#default-val}{\mathrm{default}}_t)^k \})
\end{array} \\
\end{array}\end{split}\]
Returning from a function
When the end of a function is reached without a jump (i.e., \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return}}\)) or trap aborting it, then the following steps are performed.
Let \(F\) be the current frame.
Let \(n\) be the arity of the activation of \(F\).
Assert: due to validation, there are \(n\) values on the top of the stack.
Pop the results \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) from the stack.
Assert: due to validation, the frame \(F\) is now on the top of the stack.
Pop the frame from the stack.
Push \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) back to the stack.
Jump to the instruction after the original call.
\[\begin{split}~\\[-1ex]
\begin{array}{lcl@{\qquad}l}
\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}_n\{F\}~\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}} &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& \href{../exec/runtime.html#syntax-val}{\mathit{val}}^n
\end{array}\end{split}\]
Host Functions
Invoking a host function has non-deterministic behavior.
It may either terminate with a trap or return regularly.
However, in the latter case, it must consume and produce the right number and types of WebAssembly values on the stack,
according to its function type.
A host function may also modify the store.
However, all store modifications must result in an extension of the original store, i.e., they must only modify mutable contents and must not have instances removed.
Furthermore, the resulting store must be valid, i.e., all data and code in it is well-typed.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; \href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~(\href{../exec/runtime.html#syntax-invoke}{\mathsf{invoke}}~a) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; \href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t_2^m]
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & S.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a] = \{ \href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}}~[t_1^n] \href{../syntax/types.html#syntax-functype}{\rightarrow} [t_2^m], \href{../exec/runtime.html#syntax-funcinst}{\mathsf{hostcode}}~\mathit{hf} \} \\
\end{array} \\
\end{array}\end{split}\]
During its execution, a host function call may do any of the following.
Instantiate an arbitrary WebAssembly module.
Allocate a new host function.
Continue execution, possibly spawning a new thread, with no other observable effects.
Terminate with a list of values that respects the host function’s type annotation.
Terminate with a trap.
\[\begin{split}~\\[-1ex]
\begin{array}{l}
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast]) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; (\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}_0\{F_0\}~e^\ast~\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{end}})~(\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast])
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \href{../exec/modules.html#exec-instantiation}{\mathrm{instantiate}}(S, \href{../syntax/modules.html#syntax-module}{\mathit{module}}, \href{../exec/runtime.html#syntax-externval}{\mathit{externval}}^k) = S'; F_0; e^\ast) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast]) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S'; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast])
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & \href{../exec/modules.html#alloc-hostfunc}{\mathrm{allochostfunc}}(S, \href{../syntax/types.html#syntax-functype}{\mathit{functype}}, \href{../exec/runtime.html#syntax-hostfunc}{\mathit{hostfunc}}) = S', \href{../exec/runtime.html#syntax-funcaddr}{\mathit{funcaddr}}) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast]) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}^{\href{../exec/runtime.html#syntax-act}{\mathsf{spawn}}^?}& S; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast])
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast]) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-val}{\mathit{val}}^\ast
\end{array}
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\mathrel{\mbox{if}} & S \href{../appendix/properties.html#valid-result}{\vdash} \href{../exec/runtime.html#syntax-val}{\mathit{val}}^\ast : [t^\ast]) \\[1ex]
\end{array}
\\[1ex]
\begin{array}{lcl@{\qquad}l}
S; F; (\href{../exec/runtime.html#syntax-instr-admin}{\mathsf{host}}~[t^\ast]) &\href{../exec/conventions.html#formal-notation}{\hookrightarrow}& S; F; \href{../exec/runtime.html#syntax-trap}{\mathsf{trap}}
\end{array}
\end{array}\end{split}\]
Note
A host function can call back into WebAssembly by invoking a function exported from a module.
However, the effects of any such call are subsumed by the non-deterministic behavior allowed for the host function.
