\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{nop}}\)¶

1. Do nothing.

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{unreachable}}\)¶

1. Trap.

\(\href{../syntax/instructions.html#syntax-instr-parametric}{\mathsf{drop}}\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

\(\href{../syntax/instructions.html#syntax-instr-parametric}{\mathsf{select}}~{({t^\ast})^?}\)¶

1. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) from the stack.

3. Assert: Due to validation, a value is on the top of the stack.

4. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}_2\) from the stack.

5. Assert: Due to validation, a value is on the top of the stack.

6. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}_1\) from the stack.

7. If \(c \neq 0\), then:

   1. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}_1\) to the stack.

8. Else:

   1. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}_2\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~{\mathit{bt}}~{{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}}^\ast}\)¶

1. Let \(z\) be the current state.

2. Let \({t_1^{m}}~{\mathrel{\href{../valid/conventions.html#syntax-instrtype}{\rightarrow}}}_{{{\href{../syntax/modules.html#syntax-localidx}{\mathit{localidx}}}_0^\ast}}\,{t_2^{n}}\) be the destructuring of \({{\href{../exec/runtime.html#aux-blocktype}{\mathrm{instrtype}}}}_{z}({\mathit{bt}})\).

3. Assert: Due to validation, \({{\href{../syntax/modules.html#syntax-localidx}{\mathit{localidx}}}_0^\ast} = \epsilon\).

4. Assert: Due to validation, there are at least \(m\) values on the top of the stack.

5. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{m}}\) from the stack.

6. Let \(L\) be the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) whose arity is \(n\) and whose continuation is the end of the block.

7. Enter the block \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{m}}~{{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}}^\ast}\) with the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) \(L\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{loop}}~{\mathit{bt}}~{{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}}^\ast}\)¶

1. Let \(z\) be the current state.

2. Let \({t_1^{m}}~{\mathrel{\href{../valid/conventions.html#syntax-instrtype}{\rightarrow}}}_{{{\href{../syntax/modules.html#syntax-localidx}{\mathit{localidx}}}_0^\ast}}\,{t_2^{n}}\) be the destructuring of \({{\href{../exec/runtime.html#aux-blocktype}{\mathrm{instrtype}}}}_{z}({\mathit{bt}})\).

3. Assert: Due to validation, \({{\href{../syntax/modules.html#syntax-localidx}{\mathit{localidx}}}_0^\ast} = \epsilon\).

4. Assert: Due to validation, there are at least \(m\) values on the top of the stack.

5. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{m}}\) from the stack.

6. Let \(L\) be the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) whose arity is \(m\) and whose continuation is the start of the block.

7. Enter the block \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{m}}~{{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}}^\ast}\) with the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) \(L\).

\(\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}\)¶

1. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) from the stack.

3. If \(c \neq 0\), then:

   1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{block}}~{\mathit{bt}}~{{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}}_1^\ast})\).

4. Else:

   1. Execute the instruction \((\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{br}}~l\)¶

1. If the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\), then:

   1. Let \(L\) be the topmost \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\).

   2. Let \(n\) be the arity of \(L\).

   3. If \(l = 0\), then:

      1. Assert: Due to validation, there are at least \(n\) values on the top of the stack.

      2. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) from the stack.

      3. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}^\ast}\) from the top of the stack.

      4. Pop the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) from the stack.

      5. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) to the stack.

      6. Jump to the continuation of \(L\).

   4. Else:

      1. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) from the top of the stack.

      2. Pop the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) from the stack.

      3. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

      4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l - 1)\).

2. Else:

   1. Assert: Due to validation, the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\).

   2. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) from the top of the stack.

   3. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

   4. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

   5. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_if}}~l\)¶

1. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) from the stack.

3. If \(c \neq 0\), then:

   1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

4. Else:

   1. Do nothing.

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_table}}~{l^\ast}~{l'}\)¶

1. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

3. If \(i < {|{l^\ast}|}\), then:

   1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~{l^\ast}{}[i])\).

4. Else:

   1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~{l'})\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_on\_null}}~l\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

3. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

4. Else:

   1. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_on\_non\_null}}~l\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

3. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Do nothing.

4. Else:

   1. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

   2. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_on\_cast}}~l~{\mathit{rt}}_1~{\mathit{rt}}_2\)¶

1. Let \(f\) be the topmost \(\mathsf{frame}\).

2. Assert: Due to validation, a reference value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

4. Push the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) to the stack.

5. If \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) is valid with type \({{\href{../exec/types.html#type-inst}{\mathrm{clos}}}}_{f{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}}({\mathit{rt}}_2)\), then:

   1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

6. Else:

   1. Do nothing.

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br\_on\_cast\_fail}}~l~{\mathit{rt}}_1~{\mathit{rt}}_2\)¶

1. Let \(f\) be the topmost \(\mathsf{frame}\).

2. Assert: Due to validation, a reference value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

4. Push the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) to the stack.

5. If \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) is valid with type \({{\href{../exec/types.html#type-inst}{\mathrm{clos}}}}_{f{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}}({\mathit{rt}}_2)\), then:

   1. Do nothing.

6. Else:

   1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return}}\)¶

1. If the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\), then:

   1. Let \(f\) be the topmost \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\).

   2. Let \(n\) be the arity of \(f\).

   3. Assert: Due to validation, there are at least \(n\) values on the top of the stack.

   4. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) from the stack.

   5. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}^\ast}\) from the top of the stack.

   6. Pop the \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\) from the stack.

   7. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) to the stack.

2. Else if the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\), then:

   1. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) from the top of the stack.

   2. Pop the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) from the stack.

   3. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

   4. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return}}\).

3. Else:

   1. Assert: Due to validation, the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\).

   2. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) from the top of the stack.

   3. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

   4. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

   5. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return}}\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, \(x < {|z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcs}}|}\).

3. Let \(a\) be the address \(z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcs}}{}[x]\).

4. Assert: Due to validation, \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}|}\).

5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~a)\) to the stack.

6. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_ref}}~z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}{}[a]{.}\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}})\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_ref}}~x\)¶

1. Assert: due to validation, a null or function reference is on the top of the stack.

2. Pop the reference value \(r\) from the stack.

3. If \(r\) is \(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}null}}~\mathit{ht}\), then:

   1. Trap.

4. Assert: due to validation, \(r\) is a function reference.

5. Let \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~a\) be the reference \(r\).

6. Invoke the function instance at address \(a\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_indirect}}~x~y\)¶

1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}get}}~x)\).

2. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}cast}}~(\href{../syntax/types.html#syntax-reftype}{\mathsf{ref}}~\href{../syntax/types.html#syntax-reftype}{\mathsf{null}}~y))\).

3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_ref}}~y)\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return\_call}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, \(x < {|z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcs}}|}\).

3. Let \(a\) be the address \(z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcs}}{}[x]\).

4. Assert: Due to validation, \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}|}\).

5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~a)\) to the stack.

6. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return\_call\_ref}}~z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}{}[a]{.}\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}})\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return\_call\_ref}}~y\)¶

1. Let \(z\) be the current state.

2. If the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\), then:

   1. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) from the top of the stack.

   2. Pop the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) from the stack.

   3. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

   4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return\_call\_ref}}~y)\).

3. Else if the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\), then:

   1. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) from the top of the stack.

   2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

   3. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

   4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return\_call\_ref}}~y)\).

4. Else:

   1. Assert: Due to validation, the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\).

   2. Assert: Due to validation, a value is on the top of the stack.

   3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}''}\) from the stack.

   4. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}''} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

      1. Trap.

   5. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}''}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~{\href{../exec/runtime.html#syntax-funcaddr}{\mathit{funcaddr}}}\).

   6. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}''}\).

   7. Assert: Due to validation, \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}|}\).

   8. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}{}[a]{.}\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}}\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{func}}~{\href{../syntax/types.html#syntax-resulttype}{\mathit{resulttype}}} \href{../syntax/types.html#syntax-comptype}{\rightarrow} {\href{../syntax/types.html#syntax-resulttype}{\mathit{resulttype}}}\).

   9. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{func}}~{t_1^{n}}~\href{../syntax/types.html#syntax-comptype}{\rightarrow}~{t_2^{m}})\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}{}[a]{.}\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}}\).

   10. Assert: Due to validation, there are at least \(n\) values on the top of the stack.

   11. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) from the stack.

   12. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}^\ast}\) from the top of the stack.

   13. Pop the \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\) from the stack.

   14. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) to the stack.

   15. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~a)\) to the stack.

   16. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{call\_ref}}~y)\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return\_call\_indirect}}~x~y\)¶

1. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}get}}~x)\).

2. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}cast}}~(\href{../syntax/types.html#syntax-reftype}{\mathsf{ref}}~\href{../syntax/types.html#syntax-reftype}{\mathsf{null}}~y))\).

3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return\_call\_ref}}~y)\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, \(x < {|z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tags}}|}\).

3. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tags}}{}[x]{.}\href{../exec/runtime.html#syntax-taginst}{\mathsf{type}}\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{func}}~{\href{../syntax/types.html#syntax-resulttype}{\mathit{resulttype}}} \href{../syntax/types.html#syntax-comptype}{\rightarrow} {\href{../syntax/types.html#syntax-resulttype}{\mathit{resulttype}}}\).

4. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{func}}~{t^{n}}~\href{../syntax/types.html#syntax-comptype}{\rightarrow}~{\href{../syntax/types.html#syntax-resulttype}{\mathit{resulttype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tags}}{}[x]{.}\href{../exec/runtime.html#syntax-taginst}{\mathsf{type}}\).

5. Assert: Due to validation, \({\href{../syntax/types.html#syntax-resulttype}{\mathit{resulttype}}}_0 = \epsilon\).

6. Let \(a\) be the length of \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{exns}}\).

7. Assert: Due to validation, there are at least \(n\) values on the top of the stack.

8. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) from the stack.

9. Let \({\mathit{exn}}\) be the exception instance \(\{ \href{../exec/runtime.html#syntax-exninst}{\mathsf{tag}}~z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tags}}{}[x],\;\allowbreak \href{../exec/runtime.html#syntax-exninst}{\mathsf{fields}}~{{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}} \}\).

10. Append \({\mathit{exn}}\) to \(s{.}\mathsf{exns}\).

11. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

12. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) from the stack.

4. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

5. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~{\href{../exec/runtime.html#syntax-exnaddr}{\mathit{exnaddr}}}\), then:

   1. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\).

   2. Pop all values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) from the top of the stack.

   3. If \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast} \neq \epsilon\), then:

      1. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

      2. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

   4. Else if the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\), then:

      1. Pop the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) from the stack.

      2. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

      3. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

   5. Else:

      1. If the first non-value entry of the stack is a \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\), then:

         1. Pop the \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\) from the stack.

         2. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

         3. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

      2. Else if the first non-value entry of the stack is not a \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\), then:

         1. Throw the exception \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) as a result.

      3. Else:

         1. Let \(H\) be the topmost \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\).

         2. Let \(n\) be the arity of \(H\).

         3. Let \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast}\) be the catch handler of \(H\).

         4. If \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast} = \epsilon\), then:

            1. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

            2. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

            3. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

         5. Else if \(a \geq {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{exns}}|}\), then:

            1. Let \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0~{{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\) be \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast}\).

            2. If \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\) is some \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all}}~{\href{../syntax/modules.html#syntax-labelidx}{\mathit{labelidx}}}\), then:

               1. Let \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all}}~l)\) be the destructuring of \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\).

               2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

               3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

            3. Else if \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\) is not some \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all\_ref}}~{\href{../syntax/modules.html#syntax-labelidx}{\mathit{labelidx}}}\), then:

               1. Let \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}~{{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\) be \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast}\).

               2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

               3. Let \({H'}\) be the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) whose arity is \(n\) and whose catch handler is \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\).

               4. Push the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) \({H'}\).

               5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

               6. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

            4. Else:

               1. Let \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all\_ref}}~l)\) be the destructuring of \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\).

               2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

               3. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

               4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

         6. Else:

            1. Let \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) be \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{exns}}{}[a]{.}\href{../exec/runtime.html#syntax-exninst}{\mathsf{fields}}\).

            2. Let \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0~{{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\) be \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast}\).

            3. If \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\) is some \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch}}~{\href{../syntax/modules.html#syntax-tagidx}{\mathit{tagidx}}}~{\href{../syntax/modules.html#syntax-labelidx}{\mathit{labelidx}}}\), then:

               1. Let \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch}}~x~l)\) be the destructuring of \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\).

               2. If \(x < {|z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tags}}|}\) and \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{exns}}{}[a]{.}\href{../exec/runtime.html#syntax-exninst}{\mathsf{tag}} = z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tags}}{}[x]\), then:

                  1. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

                  2. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

                  3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

               3. Else:

                  1. Let \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}~{{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\) be \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast}\).

                  2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

                  3. Let \({H'}\) be the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) whose arity is \(n\) and whose catch handler is \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\).

                  4. Push the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) \({H'}\).

                  5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

                  6. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

            4. Else if \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\) is some \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_ref}}~{\href{../syntax/modules.html#syntax-tagidx}{\mathit{tagidx}}}~{\href{../syntax/modules.html#syntax-labelidx}{\mathit{labelidx}}}\), then:

               1. Let \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_ref}}~x~l)\) be the destructuring of \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\).

               2. If \(x \geq {|z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tags}}|}\) or \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{exns}}{}[a]{.}\href{../exec/runtime.html#syntax-exninst}{\mathsf{tag}} \neq z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{tags}}{}[x]\), then:

                  1. Let \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}~{{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\) be \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast}\).

                  2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

                  3. Let \({H'}\) be the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) whose arity is \(n\) and whose catch handler is \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\).

                  4. Push the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) \({H'}\).

                  5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

                  6. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

               3. Else:

                  1. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

                  2. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

                  3. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

                  4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

            5. Else:

               1. If \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\) is some \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all}}~{\href{../syntax/modules.html#syntax-labelidx}{\mathit{labelidx}}}\), then:

                  1. Let \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all}}~l)\) be the destructuring of \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\).

                  2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

                  3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

               2. Else if \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\) is not some \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all\_ref}}~{\href{../syntax/modules.html#syntax-labelidx}{\mathit{labelidx}}}\), then:

                  1. Let \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}~{{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\) be \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}''}^\ast}\).

                  2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

                  3. Let \(H\) be the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) whose arity is \(n\) and whose catch handler is \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}'}^\ast}\).

                  4. Push the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) \(H\).

                  5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

                  6. Execute the instruction \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{throw\_ref}}\).

               3. Else:

                  1. Let \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{catch\_all\_ref}}~l)\) be the destructuring of \({\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}_0\).

                  2. Pop the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) from the stack.

                  3. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}exn}}~a)\) to the stack.

                  4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{br}}~l)\).

6. Else:

   1. Assert: Due to validation, the first non-value entry of the stack is not a \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\).

   2. Assert: Due to validation, the first non-value entry of the stack is not a \(\href{../exec/runtime.html#syntax-frame}{\mathsf{frame}}\).

   3. Assert: Due to validation, the first non-value entry of the stack is not a \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\).

   4. Throw the exception \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) as a result.

\(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{try\_table}}~{\mathit{bt}}~{{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}^\ast}~{{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}}^\ast}\)¶

1. Let \(z\) be the current state.

2. Let \({t_1^{m}}~{\mathrel{\href{../valid/conventions.html#syntax-instrtype}{\rightarrow}}}_{{{\href{../syntax/modules.html#syntax-localidx}{\mathit{localidx}}}_0^\ast}}\,{t_2^{n}}\) be the destructuring of \({{\href{../exec/runtime.html#aux-blocktype}{\mathrm{instrtype}}}}_{z}({\mathit{bt}})\).

3. Assert: Due to validation, \({{\href{../syntax/modules.html#syntax-localidx}{\mathit{localidx}}}_0^\ast} = \epsilon\).

4. Assert: Due to validation, there are at least \(m\) values on the top of the stack.

5. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{m}}\) from the stack.

6. Let \(H\) be the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) whose arity is \(n\) and whose catch handler is \({{\href{../syntax/instructions.html#syntax-catch}{\mathit{catch}}}^\ast}\).

7. Push the \(\href{../exec/runtime.html#syntax-handler}{\mathsf{handler}}\) \(H\).

8. Let \(L\) be the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) whose arity is \(n\) and whose continuation is the end of the block.

9. Enter the block \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{m}}~{{\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}}^\ast}\) with the \(\href{../exec/runtime.html#syntax-label}{\mathsf{label}}\) \(L\).

Entering \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) with label \(L\) and values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^\ast\)¶

1. Push \(L\) to the stack.

2. Push the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^\ast\) to the stack.

3. Jump to the start of the instruction sequence \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\).

Exiting \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) with label \(L\)¶

When the end of a block is reached without a jump, exception, or trap aborting it, then the following steps are performed.

1. Pop all values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^\ast\) from the top of the stack.

2. Assert: due to validation, the label \(L\) is now on the top of the stack.

3. Pop the label from the stack.

4. Push \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^\ast\) back to the stack.

5. Jump to the position after the end of the structured control instruction associated with the label \(L\).

Entering \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) with label \(L\) and exception handler \(H\)¶

1. Push \(H\) to the stack.

2. Push \(L\) onto the stack.

3. Jump to the start of the instruction sequence \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\).

Exiting an exception handler¶

When the end of a \(\mathsf{try\_table}\) block is reached without a jump, exception, or trap, then the following steps are performed.

1. Let \(m\) be the number of values on the top of the stack.

2. Pop the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m\) from the stack.

3. Assert: due to validation, a handler and a label are now on the top of the stack.

4. Pop the label from the stack.

5. Pop the handler \(H\) from the stack.

6. Push \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^m\) back to the stack.

7. Jump to the position after the end of the administrative instruction associated with the handler \(H\).

Invocation of function reference \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~a)\)¶

1. Let \(z\) be the current state.

2. Assert: due to validation, \(z.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a]\) exists.

3. Let \(\mathit{fi}\) be the function instance, \(z.\href{../exec/runtime.html#syntax-store}{\mathsf{funcs}}[a]\).

4. Let \(\href{../syntax/types.html#syntax-comptype}{\mathsf{func}}~[t_1^n] \href{../syntax/types.html#syntax-comptype}{\rightarrow} [t_2^m]\) be the composite type \(\href{../valid/conventions.html#aux-expand-deftype}{\mathrm{expand}}(\mathit{fi}.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{type}})\).

5. Let \(\href{../syntax/modules.html#syntax-func}{\mathsf{func}}~x~(\href{../syntax/modules.html#syntax-local}{\mathit{local}}~t)^\ast~\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) be the function \(\mathit{fi}.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{code}}\).

6. Assert: due to validation, \(n\) values are on the top of the stack.

7. Pop the values \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) from the stack.

8. Let \(f\) be the frame \(\{ \href{../exec/runtime.html#syntax-frame}{\mathsf{locals}}~\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n~(\href{../exec/runtime.html#aux-default}{\mathrm{default}}_t)^\ast, \href{../exec/runtime.html#syntax-frame}{\mathsf{module}}~\mathit{fi}.\href{../exec/runtime.html#syntax-funcinst}{\mathsf{module}} \}\).

9. Push the activation of \(f\) with arity \(m\) to the stack.

10. Let \(L\) be the label whose arity is \(m\) and whose continuation is the end of the function.

11. Enter the instruction sequence \(\href{../syntax/instructions.html#syntax-instr}{\mathit{instr}}^\ast\) with label \(L\) and no values.

Returning from a function¶

When the end of a function is reached without a jump (including through \(\href{../syntax/instructions.html#syntax-instr-control}{\mathsf{return}}\)), or an exception or trap aborting it, then the following steps are performed.

1. Let \(F\) be the current frame.

2. Let \(n\) be the arity of the activation of \(F\).

3. Assert: due to validation, there are \(n\) values on the top of the stack.

4. Pop the results \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) from the stack.

5. Assert: due to validation, the frame \(F\) is now on the top of the stack.

6. Pop the frame from the stack.

7. Push \(\href{../exec/runtime.html#syntax-val}{\mathit{val}}^n\) back to the stack.

8. Jump to the instruction after the original call.

Host Functions¶

Invoking a host function has non-deterministic behavior. It may either terminate with a trap, an exception, 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.

Here, \({{\mathit{hf}}}{(s, {{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}})}\) denotes the implementation-defined execution of host function \({\mathit{hf}}\) in current store \(s\) with arguments \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\). It yields a set of possible outcomes, where each element is either a pair of a modified store \({s'}\) and a result or the special value \(\bot\) indicating divergence. A host function is non-deterministic if there is at least one argument for which the set of outcomes is not singular.

For a WebAssembly implementation to be sound in the presence of host functions, every host function instance must be valid, which means that it adheres to suitable pre- and post-conditions: under a valid store \(s\), and given arguments \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) matching the ascribed parameter types \({t_1^{n}}\), executing the host function must yield a non-empty set of possible outcomes each of which is either divergence or consists of a valid store \({s'}\) that is an extension of \(s\) and a result matching the ascribed return types \({t_2^{m}}\). All these notions are made precise in the Appendix.

\(\href{../syntax/instructions.html#syntax-instr-variable}{\mathsf{local{.}get}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{locals}}{}[x]\) is defined.

3. Let \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) be \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{locals}}{}[x]\).

4. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-variable}{\mathsf{local{.}set}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

4. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{locals}}{}[x]\) with \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

\(\href{../syntax/instructions.html#syntax-instr-variable}{\mathsf{local{.}tee}}~x\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

3. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

4. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

5. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-variable}{\mathsf{local{.}set}}~x)\).

\(\href{../syntax/instructions.html#syntax-instr-variable}{\mathsf{global{.}get}}~x\)¶

1. Let \(z\) be the current state.

2. Let \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) be the value \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{globals}}{}[x]{.}\href{../exec/runtime.html#syntax-globalinst}{\mathsf{value}}\).

3. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-variable}{\mathsf{global{.}set}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

4. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{globals}}{}[x]{.}\mathsf{value}\) with \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}get}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. If \(i \geq {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}|}\), then:

   1. Trap.

5. Push the value \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}{}[i]\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}set}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a reference value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

4. Assert: Due to validation, a number value is on the top of the stack.

5. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. If \(i \geq {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}|}\), then:

   1. Trap.

7. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\mathsf{refs}{}[i]\) with \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\).

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}size}}~x\)¶

1. Let \(z\) be the current state.

2. Let \(({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})\) be the destructuring of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{type}}\).

3. Let \(n\) be the length of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}\).

4. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}grow}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a reference value is on the top of the stack.

5. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

6. Either:

   1. Let \({\mathit{ti}}\) be the table instance \({\href{../exec/modules.html#grow-table}{\mathrm{growtable}}}(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x], n, {\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}})\).

   2. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}|})\) to the stack.

   3. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]\) with \({\mathit{ti}}\).

7. Or:

   1. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{{{{\href{../exec/numerics.html#aux-signed}{\mathrm{signed}}}}_{{|{\mathit{at}}|}}^{{-1}}}}{({-1})})\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}fill}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value is on the top of the stack.

5. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

6. Assert: Due to validation, a value of number type \({\mathit{at}}\) is on the top of the stack.

7. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

8. If \(i + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}|}\), then:

   1. Trap.

9. If \(n = 0\), then:

   1. Do nothing.

10. Else:

    1. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) to the stack.

    2. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

    3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}set}}~x)\).

    4. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i + 1)\) to the stack.

    5. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

    6. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    7. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}fill}}~x)\).

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}copy}}~x_1~x_2\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a number value is on the top of the stack.

5. Pop the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) from the stack.

6. Assert: Due to validation, a number value is on the top of the stack.

7. Pop the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) from the stack.

8. If \(i_1 + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x_1]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}|}\), then:

   1. Trap.

9. If \(i_2 + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x_2]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}|}\), then:

   1. Trap.

10. If \(n = 0\), then:

    1. Do nothing.

11. Else:

    1. If \(i_1 \leq i_2\), then:

       1. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) to the stack.

       2. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) to the stack.

       3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}get}}~x_2)\).

       4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}set}}~x_1)\).

       5. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1 + 1)\) to the stack.

       6. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2 + 1)\) to the stack.

    2. Else:

       1. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1 + n - 1)\) to the stack.

       2. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2 + n - 1)\) to the stack.

       3. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}get}}~x_2)\).

       4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}set}}~x_1)\).

       5. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) to the stack.

       6. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) to the stack.

    3. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}copy}}~x_1~x_2)\).

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}init}}~x~y\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j)\) from the stack.

6. Assert: Due to validation, a number value is on the top of the stack.

7. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

8. If \(i + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{tables}}{}[x]{.}\href{../exec/runtime.html#syntax-tableinst}{\mathsf{refs}}|}\), then:

   1. Trap.

9. If \(j + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}|}\), then:

   1. Trap.

10. If \(n = 0\), then:

    1. Do nothing.

11. Else:

    1. Assert: Due to validation, \(j < {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}|}\).

    2. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) to the stack.

    3. Push the value \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}{}[j]\) to the stack.

    4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}set}}~x)\).

    5. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i + 1)\) to the stack.

    6. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j + 1)\) to the stack.

    7. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    8. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{table{.}init}}~x~y)\).

\(\href{../syntax/instructions.html#syntax-instr-table}{\mathsf{elem{.}drop}}~x\)¶

1. Let \(z\) be the current state.

2. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[x]{.}\mathsf{refs}\) with \(\epsilon\).

\({\mathit{nt}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + {|{\mathit{nt}}|} / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

5. Let \(c\) be the result for which \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\mathit{nt}}}(c)\) \(=\) \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : {|{\mathit{nt}}|} / 8]\).

6. Push the value \(({\mathit{nt}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}}{{n}{\mathsf{\_}}{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + n / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

5. Let \(c\) be the result for which \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{n}}(c)\) \(=\) \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : n / 8]\).

6. Push the value \(({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{{{{\href{../exec/numerics.html#op-extend}{\mathrm{extend}}}}_{n, {|{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}|}}^{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}}}{(c)})\) to the stack.

\(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + {|\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}|} / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

5. Let \(c\) be the result for which \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c)\) \(=\) \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : {|\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}|} / 8]\).

6. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}}{{K}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}{\mathsf{\_}}{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + K \cdot M / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

5. Let \({j^{M}}\) be the result for which \({({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{K}}({j^{M}}) = z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + k \cdot K / 8 : K / 8])^{k<M}}\).

6. Let \({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}\) be the result for which \(N\) \(=\) \(K \cdot 2\).

7. Let \(c\) be \({{{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}^{{-1}}}}{({{{{{\href{../exec/numerics.html#op-extend}{\mathrm{extend}}}}_{K, N}^{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}}}{(j)}^{M}})}\).

8. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}}{{N}{\mathsf{\_}}{\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{splat}}}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + N / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

5. Let \(M\) be \(128 / N\).

6. Let \({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}\) be the result for which \({|{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}|}\) \(=\) \(N\).

7. Let \(j\) be the result for which \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{N}}(j)\) \(=\) \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : N / 8]\).

8. Let \(c\) be \({{{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}^{{-1}}}}{({j^{M}})}\).

9. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}}{{N}{\mathsf{\_}}{\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{zero}}}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + N / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

5. Let \(j\) be the result for which \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{N}}(j)\) \(=\) \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : N / 8]\).

6. Let \(c\) be \({{{{\href{../exec/numerics.html#op-extend}{\mathrm{extend}}}}_{N, 128}^{\href{../syntax/instructions.html#syntax-sx}{\mathsf{u}}}}}{(j)}\).

7. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}}{N}{\mathsf{\_}}{\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{lane}}}~x~{\mathit{ao}}~j\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

4. Assert: Due to validation, a number value is on the top of the stack.

5. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + N / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

7. Let \(M\) be \({|\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}|} / N\).

8. Let \({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}\) be the result for which \({|{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}|}\) \(=\) \(N\).

9. Let \(k\) be the result for which \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{N}}(k)\) \(=\) \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : N / 8]\).

10. Let \(c\) be \({{{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}^{{-1}}}}{({{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c_1){}[{}[j] = k])}\).

11. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({{\mathit{nt}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}}{{{\href{../syntax/instructions.html#syntax-storeop}{\mathit{storeop}}}^?}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{nt}'}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) from the stack.

4. Assert: Due to validation, a value is on the top of the stack.

5. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. Assert: Due to validation, \({\mathit{nt}} = {\mathit{nt}'}\).

7. If \({{\href{../syntax/instructions.html#syntax-storeop}{\mathit{storeop}}}^?}\) is not defined, then:

   1. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + {|{\mathit{nt}'}|} / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

      1. Trap.

   2. Let \({b^\ast}\) be \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\mathit{nt}'}}(c)\).

   3. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : {|{\mathit{nt}'}|} / 8]\) with \({b^\ast}\).

8. Else:

   1. Assert: Due to validation, \({\mathit{nt}'}\) is \({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}\).

   2. Let \(n\) be \({{\href{../syntax/instructions.html#syntax-storeop}{\mathit{storeop}}}^?}\).

   3. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + n / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

      1. Trap.

   4. Let \({b^\ast}\) be \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{n}}({{\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}}}_{{|{\mathit{nt}'}|}, n}(c))\).

   5. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : n / 8]\) with \({b^\ast}\).

\(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}~x~{\mathit{ao}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) from the stack.

4. Assert: Due to validation, a number value is on the top of the stack.

5. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + {|\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}|} / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

7. Let \({b^\ast}\) be \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c)\).

8. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : {|\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}|} / 8]\) with \({b^\ast}\).

\({\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}}{N}{\mathsf{\_}}{\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{lane}}}~x~{\mathit{ao}}~j\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) from the stack.

4. Assert: Due to validation, a number value is on the top of the stack.

5. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. If \(i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} + N / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

7. Let \(M\) be \(128 / N\).

8. Let \({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}\) be the result for which \({|{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}|}\) \(=\) \(N\).

9. Assert: Due to validation, \(j < {|{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c)|}\).

10. Let \({b^\ast}\) be \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{N}}({{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c){}[j])\).

11. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} : N / 8]\) with \({b^\ast}\).

\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}size}}~x\)¶

1. Let \(z\) be the current state.

2. Let \(({\mathit{at}}~{\mathit{lim}}~\href{../syntax/types.html#syntax-memtype}{\mathsf{page}})\) be the destructuring of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{type}}\).

3. Let \(n \cdot 64 \, {\mathrm{Ki}}\) be the length of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}\).

4. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}grow}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Either:

   1. Let \({\mathit{mi}}\) be the memory instance \({\href{../exec/modules.html#grow-mem}{\mathrm{growmem}}}(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x], n)\).

   2. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|} / (64 \, {\mathrm{Ki}}))\) to the stack.

   3. Replace \(s{.}\mathsf{mems}{}[x]\) with \({\mathit{mi}}\).

5. Or:

   1. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{{{{\href{../exec/numerics.html#aux-signed}{\mathrm{signed}}}}_{{|{\mathit{at}}|}}^{{-1}}}}{({-1})})\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}fill}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value is on the top of the stack.

5. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

6. Assert: Due to validation, a value of number type \({\mathit{at}}\) is on the top of the stack.

7. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

8. If \(i + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

9. If \(n = 0\), then:

   1. Do nothing.

10. Else:

    1. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) to the stack.

    2. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

    3. Execute the instruction \(({\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}}{8}~x)\).

    4. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i + 1)\) to the stack.

    5. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

    6. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    7. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}fill}}~x)\).

\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}copy}}~x_1~x_2\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a number value is on the top of the stack.

3. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a number value is on the top of the stack.

5. Pop the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) from the stack.

6. Assert: Due to validation, a number value is on the top of the stack.

7. Pop the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) from the stack.

8. If \(i_1 + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x_1]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

9. If \(i_2 + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x_2]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

10. If \(n = 0\), then:

    1. Do nothing.

11. Else:

    1. If \(i_1 \leq i_2\), then:

       1. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) to the stack.

       2. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) to the stack.

       3. Execute the instruction \(({\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}}{{8}{\mathsf{\_}}{\href{../syntax/instructions.html#syntax-sx}{\mathsf{u}}}}~x_2)\).

       4. Execute the instruction \(({\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}}{8}~x_1)\).

       5. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1 + 1)\) to the stack.

       6. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2 + 1)\) to the stack.

    2. Else:

       1. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1 + n - 1)\) to the stack.

       2. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2 + n - 1)\) to the stack.

       3. Execute the instruction \(({\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}}{{8}{\mathsf{\_}}{\href{../syntax/instructions.html#syntax-sx}{\mathsf{u}}}}~x_2)\).

       4. Execute the instruction \(({\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}}{8}~x_1)\).

       5. Push the value \(({\mathit{at}}_1{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) to the stack.

       6. Push the value \(({\mathit{at}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) to the stack.

    3. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}copy}}~x_1~x_2)\).

\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}init}}~x~y\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j)\) from the stack.

6. Assert: Due to validation, a number value is on the top of the stack.

7. Pop the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

8. If \(i + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{mems}}{}[x]{.}\href{../exec/runtime.html#syntax-meminst}{\mathsf{bytes}}|}\), then:

   1. Trap.

9. If \(j + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[y]{.}\href{../exec/runtime.html#syntax-datainst}{\mathsf{bytes}}|}\), then:

   1. Trap.

10. If \(n = 0\), then:

    1. Do nothing.

11. Else:

    1. Assert: Due to validation, \(j < {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[y]{.}\href{../exec/runtime.html#syntax-datainst}{\mathsf{bytes}}|}\).

    2. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) to the stack.

    3. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[y]{.}\href{../exec/runtime.html#syntax-datainst}{\mathsf{bytes}}{}[j])\) to the stack.

    4. Execute the instruction \(({\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}}{8}~x)\).

    5. Push the value \(({\mathit{at}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i + 1)\) to the stack.

    6. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j + 1)\) to the stack.

    7. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    8. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory{.}init}}~x~y)\).

\(\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{data{.}drop}}~x\)¶

1. Let \(z\) be the current state.

2. Replace \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[x]{.}\mathsf{bytes}\) with \(\epsilon\).

\(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}null}}~{\mathit{ht}}\)¶

1. Push the value \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}func}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, \(x < {|z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcs}}|}\).

3. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}func}}~z{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}{.}\href{../exec/runtime.html#syntax-moduleinst}{\mathsf{funcs}}{}[x])\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}is\_null}}\)¶

1. Assert: Due to validation, a reference value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

3. If \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~1)\) to the stack.

4. Else:

   1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}as\_non\_null}}\)¶

1. Assert: Due to validation, a reference value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

3. If \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

4. Push the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}eq}}\)¶

1. Assert: Due to validation, a reference value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}_2\) from the stack.

3. Assert: Due to validation, a reference value is on the top of the stack.

4. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}_1\) from the stack.

5. If \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}_1 = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\) and \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}_2 = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~1)\) to the stack.

6. Else if \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}_1 = {\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}_2\), then:

   1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~1)\) to the stack.

7. Else:

   1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}test}}~{\mathit{rt}}\)¶

1. Let \(f\) be the topmost \(\mathsf{frame}\).

2. Assert: Due to validation, a reference value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

4. If \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) is valid with type \({{\href{../exec/types.html#type-inst}{\mathrm{clos}}}}_{f{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}}({\mathit{rt}})\), then:

   1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~1)\) to the stack.

5. Else:

   1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~0)\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-ref}{\mathsf{ref{.}cast}}~{\mathit{rt}}\)¶

1. Let \(f\) be the topmost \(\mathsf{frame}\).

2. Assert: Due to validation, a reference value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

4. If not \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) is valid with type \({{\href{../exec/types.html#type-inst}{\mathrm{clos}}}}_{f{.}\href{../exec/runtime.html#syntax-frame}{\mathsf{module}}}({\mathit{rt}})\), then:

   1. Trap.

5. Push the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-i31}{\mathsf{ref{.}i\scriptstyle31}}\)¶

1. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

3. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}i\scriptstyle31}}~{{\href{../exec/numerics.html#op-wrap}{\mathrm{wrap}}}}_{32, 31}(i))\) to the stack.

\({\href{../syntax/instructions.html#syntax-instr-i31}{\mathsf{i{\scriptstyle31}{.}get}}}{\mathsf{\_}}{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

3. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

4. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}i\scriptstyle31}}~{\href{../syntax/values.html#syntax-int}{\mathit{u\scriptstyle\kern-0.1em31}}}\).

5. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}i\scriptstyle31}}~i)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

6. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{{{{\href{../exec/numerics.html#op-extend}{\mathrm{extend}}}}_{31, 32}^{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}}}{(i)})\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-struct}{\mathsf{struct{.}new}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}})\).

3. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

4. Let \({({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})^{n}}\) be \({\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0\).

5. Let \(a\) be the length of \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{structs}}\).

6. Assert: Due to validation, there are at least \(n\) values on the top of the stack.

7. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) from the stack.

8. Let \({\mathit{si}}\) be the structure instance \(\{ \href{../exec/runtime.html#syntax-structinst}{\mathsf{type}}~z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x],\;\allowbreak \href{../exec/runtime.html#syntax-structinst}{\mathsf{fields}}~{{{\href{../exec/runtime.html#aux-packfield}{\mathrm{pack}}}}_{{\mathit{zt}}}({\href{../exec/runtime.html#syntax-val}{\mathit{val}}})^{n}} \}\).

9. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}struct}}~a)\) to the stack.

10. Append \({\mathit{si}}\) to \(s{.}\mathsf{structs}\).

\(\href{../syntax/instructions.html#syntax-instr-struct}{\mathsf{struct{.}new\_default}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}})\).

3. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

4. Let \({({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})^\ast}\) be \({\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0\).

5. Assert: Due to validation, for all \({\mathit{zt}}\) in \({{\mathit{zt}}^\ast}\), \({{\href{../exec/runtime.html#aux-default}{\mathrm{default}}}}_{{\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\mathit{zt}})}\) is defined.

6. Let \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) be the value sequence \(\epsilon\).

7. For each \({\mathit{zt}}\) in \({{\mathit{zt}}^\ast}\), do:

   1. Let \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) be \({{\href{../exec/runtime.html#aux-default}{\mathrm{default}}}}_{{\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\mathit{zt}})}\).

   2. Append \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\).

8. Assert: Due to validation, \({|{{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}|} = {|{{\mathit{zt}}^\ast}|}\).

9. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^\ast}\) to the stack.

10. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-struct}{\mathsf{struct{.}new}}~x)\).

\({\href{../syntax/instructions.html#syntax-instr-struct}{\mathsf{struct{.}get}}}{\mathsf{\_}}{{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}^?}}~x~i\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

4. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

5. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}struct}}~{\href{../exec/runtime.html#syntax-structaddr}{\mathit{structaddr}}}\).

6. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}struct}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

7. Assert: Due to validation, \(i < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{structs}}{}[a]{.}\href{../exec/runtime.html#syntax-structinst}{\mathsf{fields}}|}\).

8. Assert: Due to validation, \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{structs}}|}\).

9. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}})\).

10. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

11. Let \({({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})^\ast}\) be \({\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0\).

12. Assert: Due to validation, \(i < {|{{\mathit{zt}}^\ast}|}\).

13. Push the value \({{{{\href{../exec/runtime.html#aux-unpackfield}{\mathrm{unpack}}}}_{{{\mathit{zt}}^\ast}{}[i]}^{{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}^?}}}}{(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{structs}}{}[a]{.}\href{../exec/runtime.html#syntax-structinst}{\mathsf{fields}}{}[i])}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-struct}{\mathsf{struct{.}set}}~x~i\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

4. Assert: Due to validation, a value is on the top of the stack.

5. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) from the stack.

6. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

7. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}struct}}~{\href{../exec/runtime.html#syntax-structaddr}{\mathit{structaddr}}}\).

8. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}struct}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\).

9. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}})\).

10. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{struct}}~{\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

11. Let \({({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})^\ast}\) be \({\href{../syntax/conventions.html#syntax-list}{\mathit{list}}}_0\).

12. Assert: Due to validation, \(i < {|{{\mathit{zt}}^\ast}|}\).

13. Replace \(s{.}\mathsf{structs}{}[a]{.}\mathsf{fields}{}[i]\) with \({{\href{../exec/runtime.html#aux-packfield}{\mathrm{pack}}}}_{{{\mathit{zt}}^\ast}{}[i]}({\href{../exec/runtime.html#syntax-val}{\mathit{val}}})\).

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new}}~x\)¶

1. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

3. Assert: Due to validation, a value is on the top of the stack.

4. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

5. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) to the stack.

6. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_fixed}}~x~n)\).

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_default}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}\).

5. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

6. Let \(({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})\) be the destructuring of \({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0\).

7. Assert: Due to validation, \({{\href{../exec/runtime.html#aux-default}{\mathrm{default}}}}_{{\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\mathit{zt}})}\) is defined.

8. Let \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) be \({{\href{../exec/runtime.html#aux-default}{\mathrm{default}}}}_{{\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\mathit{zt}})}\).

9. Push the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) to the stack.

10. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_fixed}}~x~n)\).

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_fixed}}~x~n\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}\).

3. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

4. Let \(({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})\) be the destructuring of \({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0\).

5. Let \(a\) be the length of \(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}\).

6. Assert: Due to validation, there are at least \(n\) values on the top of the stack.

7. Pop the values \({{\href{../exec/runtime.html#syntax-val}{\mathit{val}}}^{n}}\) from the stack.

8. Let \({\mathit{ai}}\) be the array instance \(\{ \href{../exec/runtime.html#syntax-arrayinst}{\mathsf{type}}~z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x],\;\allowbreak \href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}~{{{\href{../exec/runtime.html#aux-packfield}{\mathrm{pack}}}}_{{\mathit{zt}}}({\href{../exec/runtime.html#syntax-val}{\mathit{val}}})^{n}} \}\).

9. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) to the stack.

10. Append \({\mathit{ai}}\) to \(s{.}\mathsf{arrays}\).

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_data}}~x~y\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}\).

7. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

8. Let \(({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})\) be the destructuring of \({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0\).

9. If \(i + n \cdot {|{\mathit{zt}}|} / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[y]{.}\href{../exec/runtime.html#syntax-datainst}{\mathsf{bytes}}|}\), then:

   1. Trap.

10. Let \({{{\href{../syntax/values.html#syntax-byte}{\mathit{byte}}}^\ast}^\ast}\) be the result for which each \({{\href{../syntax/values.html#syntax-byte}{\mathit{byte}}}^\ast}\) has length \({|{\mathit{zt}}|} / 8\), and the concatenation of \({{{\href{../syntax/values.html#syntax-byte}{\mathit{byte}}}^\ast}^\ast}\) is \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[y]{.}\href{../exec/runtime.html#syntax-datainst}{\mathsf{bytes}}{}[i : n \cdot {|{\mathit{zt}}|} / 8]\).

11. Let \({c^{n}}\) be the result for which \({({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\mathit{zt}}}({c^{n}}) = {{\href{../syntax/values.html#syntax-byte}{\mathit{byte}}}^\ast})^\ast}\).

12. Push the values \({{\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\mathit{zt}}){.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{{\href{../exec/numerics.html#aux-unpacknum}{\mathrm{unpack}}}}_{{\mathit{zt}}}(c)^{n}}\) to the stack.

13. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_fixed}}~x~n)\).

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_elem}}~x~y\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. If \(i + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}|}\), then:

   1. Trap.

7. Let \({{\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}^{n}}\) be \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}{}[i : n]\).

8. Push the values \({{\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}^{n}}\) to the stack.

9. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}new\_fixed}}~x~n)\).

\({\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}get}}}{\mathsf{\_}}{{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}^?}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

4. Assert: Due to validation, a value is on the top of the stack.

5. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

6. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

7. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\).

8. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

9. Assert: Due to validation, \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\).

10. If \(i \geq {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|}\), then:

    1. Trap.

11. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}\).

12. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

13. Let \(({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})\) be the destructuring of \({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0\).

14. Push the value \({{{{\href{../exec/runtime.html#aux-unpackfield}{\mathrm{unpack}}}}_{{\mathit{zt}}}^{{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}^?}}}}{(z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}{}[i])}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}set}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

6. Assert: Due to validation, a value is on the top of the stack.

7. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) from the stack.

8. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

9. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\).

10. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\).

11. If \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\) and \(i \geq {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|}\), then:

    1. Trap.

12. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}\).

13. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

14. Let \(({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})\) be the destructuring of \({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0\).

15. Replace \(s{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}{}[i]\) with \({{\href{../exec/runtime.html#aux-packfield}{\mathrm{pack}}}}_{{\mathit{zt}}}({\href{../exec/runtime.html#syntax-val}{\mathit{val}}})\).

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}len}}\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value is on the top of the stack.

3. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

4. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Trap.

5. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\).

6. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

7. Assert: Due to validation, \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\).

8. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|})\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}fill}}~x\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value is on the top of the stack.

5. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

6. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

7. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

8. Assert: Due to validation, a value is on the top of the stack.

9. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) from the stack.

10. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

    1. Trap.

11. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\).

12. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\).

13. If \(a \geq {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\), then:

    1. Do nothing.

14. Else if \(i + n > {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|}\), then:

    1. Trap.

15. If \(n = 0\), then:

    1. Do nothing.

16. Else:

    1. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) to the stack.

    2. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) to the stack.

    3. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

    4. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}set}}~x)\).

    5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) to the stack.

    6. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i + 1)\) to the stack.

    7. Push the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) to the stack.

    8. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    9. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}fill}}~x)\).

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}copy}}~x_1~x_2\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) from the stack.

6. Assert: Due to validation, a value is on the top of the stack.

7. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

8. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

9. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) from the stack.

10. Assert: Due to validation, a value is on the top of the stack.

11. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) from the stack.

12. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\) and \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is reference value, then:

    1. Trap.

13. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\) and \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) is reference value, then:

    1. Trap.

14. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\), then:

    1. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_1)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}'}\).

    2. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\), then:

       1. If \(a_1 < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\) and \(i_1 + n > {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a_1]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|}\), then:

          1. Trap.

       2. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_2)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

       3. If \(a_2 \geq {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\), then:

          1. Do nothing.

       4. Else if \(i_2 + n > {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a_2]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|}\), then:

          1. Trap.

       5. If \(n = 0\), then:

          1. Do nothing.

       6. Else:

          1. Assert: Due to validation, the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x_2]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}\).

          2. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x_2]\).

          3. Let \(({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}}_2)\) be the destructuring of \({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0\).

          4. Let \({{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}^?}\) be \({\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}({\mathit{zt}}_2)\).

          5. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_1)\) to the stack.

          6. If \(i_1 \leq i_2\), then:

             1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) to the stack.

             2. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_2)\) to the stack.

             3. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) to the stack.

             4. Execute the instruction \(({\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}get}}}{\mathsf{\_}}{{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}^?}}~x_2)\).

             5. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}set}}~x_1)\).

             6. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_1)\) to the stack.

             7. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1 + 1)\) to the stack.

             8. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_2)\) to the stack.

             9. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2 + 1)\) to the stack.

          7. Else:

             1. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1 + n - 1)\) to the stack.

             2. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_2)\) to the stack.

             3. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2 + n - 1)\) to the stack.

             4. Execute the instruction \(({\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}get}}}{\mathsf{\_}}{{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}^?}}~x_2)\).

             5. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}set}}~x_1)\).

             6. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_1)\) to the stack.

             7. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_1)\) to the stack.

             8. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a_2)\) to the stack.

             9. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i_2)\) to the stack.

          8. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

          9. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}copy}}~x_1~x_2)\).

Where:

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}init\_data}}~x~y\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j)\) from the stack.

6. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

7. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

8. Assert: Due to validation, a value is on the top of the stack.

9. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

10. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

    1. Trap.

11. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\).

12. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

13. If \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\) and \(i + n > {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|}\), then:

    1. Trap.

14. If the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\) is some \(\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}\), then:

    1. Let \((\href{../syntax/types.html#syntax-comptype}{\mathsf{array}}~{\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0)\) be the destructuring of the expansion of \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{types}}{}[x]\).

    2. Let \(({\href{../syntax/types.html#syntax-mut}{\mathsf{mut}}^?}~{\mathit{zt}})\) be the destructuring of \({\href{../syntax/types.html#syntax-fieldtype}{\mathit{fieldtype}}}_0\).

    3. If \(j + n \cdot {|{\mathit{zt}}|} / 8 > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[y]{.}\href{../exec/runtime.html#syntax-datainst}{\mathsf{bytes}}|}\), then:

       1. Trap.

    4. If \(n = 0\), then:

       1. Do nothing.

    5. Else:

       1. Let \(c\) be the result for which \({{\href{../exec/numerics.html#aux-bytes}{\mathrm{bytes}}}}_{{\mathit{zt}}}(c)\) \(=\) \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{datas}}{}[y]{.}\href{../exec/runtime.html#syntax-datainst}{\mathsf{bytes}}{}[j : {|{\mathit{zt}}|} / 8]\).

       2. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) to the stack.

       3. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) to the stack.

       4. Push the value \({\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\mathit{zt}}){.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~{{\href{../exec/numerics.html#aux-unpacknum}{\mathrm{unpack}}}}_{{\mathit{zt}}}(c)\) to the stack.

       5. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}set}}~x)\).

       6. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) to the stack.

       7. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i + 1)\) to the stack.

       8. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j + {|{\mathit{zt}}|} / 8)\) to the stack.

       9. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

       10. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}init\_data}}~x~y)\).

15. Else if \(n = 0\), then:

    1. Do nothing.

\(\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}init\_elem}}~x~y\)¶

1. Let \(z\) be the current state.

2. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

3. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n)\) from the stack.

4. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j)\) from the stack.

6. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

7. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

8. Assert: Due to validation, a value is on the top of the stack.

9. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

10. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

    1. Trap.

11. Assert: Due to validation, \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~{\href{../exec/runtime.html#syntax-arrayaddr}{\mathit{arrayaddr}}}\).

12. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

13. If \(a < {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}|}\) and \(i + n > {|z{.}\href{../exec/runtime.html#syntax-store}{\mathsf{arrays}}{}[a]{.}\href{../exec/runtime.html#syntax-arrayinst}{\mathsf{fields}}|}\), then:

    1. Trap.

14. If \(j + n > {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}|}\), then:

    1. Trap.

15. If \(n = 0\), then:

    1. Do nothing.

16. Else if \(j < {|z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}|}\), then:

    1. Let \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) be the reference value \(z{.}\href{../exec/runtime.html#syntax-state}{\mathsf{elems}}{}[y]{.}\href{../exec/runtime.html#syntax-eleminst}{\mathsf{refs}}{}[j]\).

    2. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) to the stack.

    3. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) to the stack.

    4. Push the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) to the stack.

    5. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}set}}~x)\).

    6. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}array}}~a)\) to the stack.

    7. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i + 1)\) to the stack.

    8. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~j + 1)\) to the stack.

    9. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n - 1)\) to the stack.

    10. Execute the instruction \((\href{../syntax/instructions.html#syntax-instr-array}{\mathsf{array{.}init\_elem}}~x~y)\).

\(\href{../syntax/instructions.html#syntax-instr-extern}{\mathsf{any{.}convert\_extern}}\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) from the stack.

3. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Push the value \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\) to the stack.

4. If \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\) is some \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}extern}}~{\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\), then:

   1. Let \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}extern}}~{\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}})\) be the destructuring of \({\href{../exec/runtime.html#syntax-val}{\mathit{val}}}\).

   2. Push the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) to the stack.

\(\href{../syntax/instructions.html#syntax-instr-extern}{\mathsf{extern{.}convert\_any}}\)¶

1. Assert: Due to validation, a reference value is on the top of the stack.

2. Pop the value \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}}\) from the stack.

3. If \({\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}} = \href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\), then:

   1. Push the value \(\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}null}}\) to the stack.

4. Else:

   1. Push the value \((\href{../exec/runtime.html#syntax-ref}{\mathsf{ref{.}extern}}~{\href{../exec/runtime.html#syntax-ref}{\mathit{ref}}})\) to the stack.

\(\mathit{nt}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c\)¶

1. Push the value \(({\mathit{nt}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{nt}} {.} {\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}}\)¶

1. Assert: Due to validation, a value of number type \({\mathit{nt}}\) is on the top of the stack.

2. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. If \({{\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}}}{{}_{{\mathit{nt}}}(c_1)}\) is empty, then:

   1. Trap.

4. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-unop}{\mathit{unop}}}}{{}_{{\mathit{nt}}}(c_1)}\).

5. Push the value \(({\mathit{nt}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{nt}} {.} {\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}}\)¶

1. Assert: Due to validation, a value of number type \({\mathit{nt}}\) is on the top of the stack.

2. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a number value is on the top of the stack.

4. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. If \({{\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}}}{{}_{{\mathit{nt}}}(c_1, c_2)}\) is empty, then:

   1. Trap.

6. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-binop}{\mathit{binop}}}}{{}_{{\mathit{nt}}}(c_1, c_2)}\).

7. Push the value \(({\mathit{nt}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{nt}} {.} {\href{../syntax/instructions.html#syntax-testop}{\mathit{testop}}}\)¶

1. Assert: Due to validation, a value of number type \({\mathit{nt}}\) is on the top of the stack.

2. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-testop}{\mathit{testop}}}}{{}_{{\mathit{nt}}}(c_1)}\).

4. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{nt}} {.} {\href{../syntax/instructions.html#syntax-relop}{\mathit{relop}}}\)¶

1. Assert: Due to validation, a value of number type \({\mathit{nt}}\) is on the top of the stack.

2. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a number value is on the top of the stack.

4. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-relop}{\mathit{relop}}}}{{}_{{\mathit{nt}}}(c_1, c_2)}\).

6. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{nt}}_2 {.} {{\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}}}{\mathsf{\_}}{{\mathit{nt}}_1}\)¶

1. Assert: Due to validation, a value of number type \({\mathit{nt}}_1\) is on the top of the stack.

2. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. If \({{\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}}}{{}_{{\mathit{nt}}_1, {\mathit{nt}}_2}(c_1)}\) is empty, then:

   1. Trap.

4. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-cvtop}{\mathit{cvtop}}}}{{}_{{\mathit{nt}}_1, {\mathit{nt}}_2}(c_1)}\).

5. Push the value \(({\mathit{nt}}_2{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\mathsf{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{const}}~c\)¶

1. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}} {.} {\href{../syntax/instructions.html#syntax-vvunop}{\mathit{vvunop}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Assert: Due to validation, \({|{{\href{../syntax/instructions.html#syntax-vvunop}{\mathit{vvunop}}}}{{}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c_1)}|} > 0\).

4. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-vvunop}{\mathit{vvunop}}}}{{}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c_1)}\).

5. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}} {.} {\href{../syntax/instructions.html#syntax-vvbinop}{\mathit{vvbinop}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Assert: Due to validation, \({|{{\href{../syntax/instructions.html#syntax-vvbinop}{\mathit{vvbinop}}}}{{}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c_1, c_2)}|} > 0\).

6. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-vvbinop}{\mathit{vvbinop}}}}{{}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c_1, c_2)}\).

7. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}} {.} {\href{../syntax/instructions.html#syntax-vvternop}{\mathit{vvternop}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

5. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

6. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

7. Assert: Due to validation, \({|{{\href{../syntax/instructions.html#syntax-vvternop}{\mathit{vvternop}}}}{{}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c_1, c_2, c_3)}|} > 0\).

8. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-vvternop}{\mathit{vvternop}}}}{{}_{\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}}(c_1, c_2, c_3)}\).

9. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}} {.} \href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{any\_true}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Let \(c\) be \({{\href{../exec/numerics.html#op-inez}{\mathrm{inez}}}}_{{|\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}|}}(c_1)\).

4. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}} {.} {\href{../syntax/instructions.html#syntax-vunop}{\mathit{vunop}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. If \({{\href{../syntax/instructions.html#syntax-vunop}{\mathit{vunop}}}}{{}_{{\mathit{sh}}}(c_1)}\) is empty, then:

   1. Trap.

4. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-vunop}{\mathit{vunop}}}}{{}_{{\mathit{sh}}}(c_1)}\).

5. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}} {.} {\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. If \({{\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}}}{{}_{{\mathit{sh}}}(c_1, c_2)}\) is empty, then:

   1. Trap.

6. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-vbinop}{\mathit{vbinop}}}}{{}_{{\mathit{sh}}}(c_1, c_2)}\).

7. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}} {.} {\href{../syntax/instructions.html#syntax-vternop}{\mathit{vternop}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

5. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

6. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

7. If \({{\href{../syntax/instructions.html#syntax-vternop}{\mathit{vternop}}}}{{}_{{\mathit{sh}}}(c_1, c_2, c_3)}\) is empty, then:

   1. Trap.

8. Let \(c\) be an element of \({{\href{../syntax/instructions.html#syntax-vternop}{\mathit{vternop}}}}{{}_{{\mathit{sh}}}(c_1, c_2, c_3)}\).

9. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M} {.} \href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{all\_true}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Let \({i^\ast}\) be \({{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c_1)\).

4. Let \(c\) be \({\Pi}\, {{{\href{../exec/numerics.html#op-inez}{\mathrm{inez}}}}_{N}(i)^\ast}\).

5. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}} {.} {\href{../syntax/instructions.html#syntax-vrelop}{\mathit{vrelop}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-vrelop}{\mathit{vrelop}}}}{{}_{{\mathit{sh}}}(c_1, c_2)}\).

6. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}} {.} {\href{../syntax/instructions.html#syntax-vshiftop}{\mathit{vshiftop}}}\)¶

1. Assert: Due to validation, a value of number type \(\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~i)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-vshiftop}{\mathit{vshiftop}}}}{{}_{{\mathit{sh}}}}{(c_1, i)}\).

6. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}}{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{bitmask}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Let \(c\) be \({\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{bitmask}}}{{}_{{\mathit{sh}}}(c_1)}\).

4. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}} {.} {\mathit{swizzlop}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Let \(c\) be \({{\mathit{swizzlop}}}{{}_{{\mathit{sh}}}(c_1, c_2)}\).

6. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}}{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{shuffle}}~{i^\ast}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Let \(c\) be \({\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{shuffle}}}{{}_{{\mathit{sh}}}({i^\ast}, c_1, c_2)}\).

6. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{splat}}\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Assert: Due to validation, \({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0 = {\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}})\).

4. Let \(c\) be \({{{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}^{{-1}}}}{({{{\href{../exec/numerics.html#aux-packnum}{\mathrm{pack}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}(c_1)^{M}})}\).

5. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({{{\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{extract\_lane}}}{\mathsf{\_}}{{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}'}^?}}~i\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. If \({{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}'}^?}\) is not defined, then:

   1. Assert: Due to validation, \({\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}\) is number type.

   2. Assert: Due to validation, \(i < {|{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c_1)|}\).

   3. Let \(c_2\) be \({{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c_1){}[i]\).

   4. Push the value \(({\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) to the stack.

4. Else:

   1. Assert: Due to validation, \({\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}\) is packed type.

   2. Let \({\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}\) be \({{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}'}^?}\).

   3. Assert: Due to validation, \(i < {|{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c_1)|}\).

   4. Let \(c_2\) be \({{{{\href{../exec/numerics.html#op-extend}{\mathrm{extend}}}}_{{|{\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}|}, 32}^{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}}}{({{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/instructions.html#syntax-lanetype}{\mathit{lanetype}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c_1){}[i])}\).

   5. Push the value \((\href{../syntax/types.html#syntax-numtype}{\mathsf{i\scriptstyle32}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) to the stack.

\({{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{replace\_lane}}~i\)¶

1. Assert: Due to validation, a value is on the top of the stack.

2. Pop the value \(({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, \({\href{../syntax/types.html#syntax-numtype}{\mathit{numtype}}}_0 = {\href{../syntax/types.html#aux-unpack}{\mathrm{unpack}}}({\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}})\).

4. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

5. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

6. Let \(c\) be \({{{{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}^{{-1}}}}{({{\href{../exec/numerics.html#aux-lanes}{\mathrm{lanes}}}}_{{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}{\href{../syntax/instructions.html#syntax-shape}{\mathsf{x}}}{M}}(c_1){}[{}[i] = {{\href{../exec/numerics.html#aux-packnum}{\mathrm{pack}}}}_{{\href{../syntax/types.html#syntax-numtype}{\mathsf{i}}}{{\href{../syntax/types.html#syntax-numtype}{\scriptstyle\kern-0.1emN}}}}(c_2)])}\).

7. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}}_2 {.} {{\href{../syntax/instructions.html#syntax-vextunop}{\mathit{vextunop}}}}{\mathsf{\_}}{{\mathit{sh}}_1}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-vextunop}{\mathit{vextunop}}}}{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}(c_1)}\).

4. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}}_2 {.} {{\href{../syntax/instructions.html#syntax-vextbinop}{\mathit{vextbinop}}}}{\mathsf{\_}}{{\mathit{sh}}_1}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-vextbinop}{\mathit{vextbinop}}}}{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}(c_1, c_2)}\).

6. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}}_2 {.} {{\href{../syntax/instructions.html#syntax-vextternop}{\mathit{vextternop}}}}{\mathsf{\_}}{{\mathit{sh}}_1}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_3)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

5. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

6. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

7. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-vextternop}{\mathit{vextternop}}}}{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}(c_1, c_2, c_3)}\).

8. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({{\mathit{sh}}_2{.}\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{narrow}}}{\mathsf{\_}}{{\mathit{sh}}_1}{\mathsf{\_}}{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_2)\) from the stack.

3. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

4. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

5. Let \(c\) be \({\href{../syntax/instructions.html#syntax-instr-vec}{\mathsf{narrow}}}{{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}^{{\href{../syntax/instructions.html#syntax-sx}{\mathit{sx}}}}}}{(c_1, c_2)}\).

6. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.

\({\mathit{sh}}_2 {.} {{\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}}}{\mathsf{\_}}{{\mathit{sh}}_1}\)¶

1. Assert: Due to validation, a value of vector type \(\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}\) is on the top of the stack.

2. Pop the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c_1)\) from the stack.

3. Let \(c\) be \({{\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}}}_{{\mathit{sh}}_1, {\mathit{sh}}_2}({\href{../syntax/instructions.html#syntax-vcvtop}{\mathit{vcvtop}}}, c_1)\).

4. Push the value \((\href{../syntax/types.html#syntax-vectype}{\mathsf{v\scriptstyle128}}{.}\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~c)\) to the stack.