| # Preview |
| |
| ```sh |
| $ for v in 1 2 3; do ( \ |
| > echo "Generating prose for Wasm $v.0..." && \ |
| > ../src/exe-spectec/main.exe ../../../../specification/wasm-$v.0/*.spectec -v -l --prose-rst && \ |
| > ../src/exe-spectec/main.exe ../../../../specification/wasm-$v.0/*.spectec -v -l --prose \ |
| > ) done |
| Generating prose for Wasm 1.0... |
| spectec 0.5 generator |
| == Parsing... |
| == Elaboration... |
| == IL Validation... |
| == Running pass sideconditions... |
| == IL Validation after pass sideconditions... |
| == Translating to AL... |
| == Prose Generation... |
| |
| |
| |
| The limits :math:`{}[ n .. {m^?} ]` is :ref:`valid <valid-val>` with :math:`k` if: |
| |
| |
| * :math:`n` is less than or equal to :math:`k`. |
| |
| * If :math:`m` is defined, then: |
| |
| * :math:`n` is less than or equal to :math:`m`. |
| |
| * :math:`m` is less than or equal to :math:`k`. |
| |
| |
| |
| |
| The function type :math:`{t_1^\ast}~\rightarrow~{t_2^?}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The global type :math:`({\mathsf{mut}^?}~t)` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The table type :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The limits :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` with :math:`{2^{32}} - 1`. |
| |
| |
| |
| |
| The memory type :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The limits :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` with :math:`{2^{16}}`. |
| |
| |
| |
| |
| The external type :math:`{\mathit{externtype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{func}~{\mathit{functype}})`. |
| |
| * The function type :math:`{\mathit{functype}}` is :ref:`valid <valid-val>`. |
| |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{global}~{\mathit{globaltype}})`. |
| |
| * The global type :math:`{\mathit{globaltype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{table}~{\mathit{tabletype}})`. |
| |
| * The table type :math:`{\mathit{tabletype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{mem}~{\mathit{memtype}})`. |
| |
| * The memory type :math:`{\mathit{memtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{func}~{\mathit{functype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The function type :math:`{\mathit{functype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{global}~{\mathit{globaltype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The global type :math:`{\mathit{globaltype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{table}~{\mathit{tabletype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The table type :math:`{\mathit{tabletype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{mem}~{\mathit{memtype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The memory type :math:`{\mathit{memtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The limits :math:`{}[ n_{11} .. n_{12} ]` :ref:`matches <match>` the limits :math:`{}[ n_{21} .. n_{22} ]` if: |
| |
| |
| * :math:`n_{11}` is greater than or equal to :math:`n_{21}`. |
| |
| * :math:`n_{12}` is less than or equal to :math:`n_{22}`. |
| |
| |
| |
| |
| The function type :math:`{\mathit{ft}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The global type :math:`{\mathit{gt}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The table type :math:`{\mathit{lim}}_1` :ref:`matches <match>` the table type :math:`{\mathit{lim}}_2` if: |
| |
| |
| * The limits :math:`{\mathit{lim}}_1` :ref:`matches <match>` the limits :math:`{\mathit{lim}}_2`. |
| |
| |
| |
| |
| The memory type :math:`{\mathit{lim}}_1` :ref:`matches <match>` the memory type :math:`{\mathit{lim}}_2` if: |
| |
| |
| * The limits :math:`{\mathit{lim}}_1` :ref:`matches <match>` the limits :math:`{\mathit{lim}}_2`. |
| |
| |
| |
| |
| The external type :math:`{\mathit{externtype}}_1` :ref:`matches <match>` the external type :math:`{\mathit{externtype}}_2` if: |
| |
| |
| * Either: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{func}~{\mathit{ft}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{func}~{\mathit{ft}}_2)`. |
| |
| * The function type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the function type :math:`{\mathit{ft}}_2`. |
| |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{global}~{\mathit{gt}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{global}~{\mathit{gt}}_2)`. |
| |
| * The global type :math:`{\mathit{gt}}_1` :ref:`matches <match>` the global type :math:`{\mathit{gt}}_2`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{table}~{\mathit{tt}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{table}~{\mathit{tt}}_2)`. |
| |
| * The table type :math:`{\mathit{tt}}_1` :ref:`matches <match>` the table type :math:`{\mathit{tt}}_2`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{mem}~{\mathit{mt}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{mem}~{\mathit{mt}}_2)`. |
| |
| * The memory type :math:`{\mathit{mt}}_1` :ref:`matches <match>` the memory type :math:`{\mathit{mt}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{func}~{\mathit{ft}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{func}~{\mathit{ft}}_2)` if: |
| |
| |
| * The function type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the function type :math:`{\mathit{ft}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{global}~{\mathit{gt}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{global}~{\mathit{gt}}_2)` if: |
| |
| |
| * The global type :math:`{\mathit{gt}}_1` :ref:`matches <match>` the global type :math:`{\mathit{gt}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{table}~{\mathit{tt}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{table}~{\mathit{tt}}_2)` if: |
| |
| |
| * The table type :math:`{\mathit{tt}}_1` :ref:`matches <match>` the table type :math:`{\mathit{tt}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{mem}~{\mathit{mt}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{mem}~{\mathit{mt}}_2)` if: |
| |
| |
| * The memory type :math:`{\mathit{mt}}_1` :ref:`matches <match>` the memory type :math:`{\mathit{mt}}_2`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{nop}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{unreachable}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{drop}` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{select}` is :ref:`valid <valid-val>` with the function type :math:`t~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{block}~{t^?}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{t^?}` if: |
| |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t^?}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{t^?}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{loop}~{t^?}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{t^?}` if: |
| |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`\epsilon` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{if}~{t^?}~{{\mathit{instr}}_1^\ast}~\mathsf{else}~{{\mathit{instr}}_2^\ast})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~{t^?}` if: |
| |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t^?}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}_1^\ast}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{t^?}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{t^?}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br}~l)` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~{t^?}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The number type :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^?}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_if}~l)` is :ref:`valid <valid-val>` with the function type :math:`{t^?}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t^?}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The number type :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^?}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_table}~{l^\ast}~{l'})` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~{t^?}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[{l'}]` exists. |
| |
| * The result type :math:`{t^?}` is of the form :math:`C{.}\mathsf{labels}{}[{l'}]`. |
| |
| * For all :math:`l` in :math:`{l^\ast}`: |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`{t^?}` is of the form :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{call}~x)` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^?}` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{t_1^\ast}~\rightarrow~{t_2^?}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{call\_indirect}~x)` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^?}` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[x]` is of the form :math:`{t_1^\ast}~\rightarrow~{t_2^?}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{return}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~{t^?}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{return}` is of the form :math:`{t^?}`. |
| |
| |
| |
| |
| The instruction :math:`(t{.}\mathsf{const}~c_t)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~t`. |
| |
| |
| |
| |
| The instruction :math:`(t {.} {\mathit{unop}}_t)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~t`. |
| |
| |
| |
| |
| The instruction :math:`(t {.} {\mathit{binop}}_t)` is :ref:`valid <valid-val>` with the function type :math:`t~t~\rightarrow~t`. |
| |
| |
| |
| |
| The instruction :math:`(t {.} {\mathit{testop}}_t)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`(t {.} {\mathit{relop}}_t)` is :ref:`valid <valid-val>` with the function type :math:`t~t~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}_1 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{nt}}_2})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}_2~\rightarrow~{\mathit{nt}}_1` if: |
| |
| |
| * Either: |
| |
| * :math:`{\mathit{cvtop}}` is of the form :math:`\mathsf{reinterpret}`. |
| |
| * :math:`{|{\mathit{nt}}_1|}` is of the form :math:`{|{\mathit{nt}}_2|}`. |
| |
| * Or: |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}get}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~t` if: |
| |
| |
| * The number type :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The number type :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}set}~x)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~\epsilon` if: |
| |
| |
| * The number type :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The number type :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}tee}~x)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~t` if: |
| |
| |
| * The number type :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The number type :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{global{.}get}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~t` if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`({\mathit{mut}}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{global{.}set}~x)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~\epsilon` if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\mathsf{mut}~t)`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{memory{.}size}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{memory{.}grow}` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({t{.}\mathsf{load}}{{{\mathit{loadop}}^?}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~{t'}` if: |
| |
| |
| * Either: |
| |
| * :math:`{{\mathit{loadop}}^?}` is absent. |
| |
| * The number type :math:`{t'}` is of the form :math:`t`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|t|} / 8`. |
| |
| * Or: |
| |
| * The number type :math:`t` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * :math:`{{\mathit{loadop}}^?}` is of the form :math:`{M}{\mathsf{\_}}{{\mathit{sx}}}`. |
| |
| * The number type :math:`{t'}` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction :math:`({t{.}\mathsf{store}}{{{\mathit{sz}}^?}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~{t'}~\rightarrow~\epsilon` if: |
| |
| |
| * Either: |
| |
| * The pack size :math:`{{\mathit{sz}}^?}` is absent. |
| |
| * The number type :math:`{t'}` is of the form :math:`t`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|t|} / 8`. |
| |
| * Or: |
| |
| * The number type :math:`t` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * The pack size :math:`{{\mathit{sz}}^?}` is of the form :math:`M`. |
| |
| * The number type :math:`{t'}` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}_1 {.} {\mathsf{reinterpret}}{\mathsf{\_}}{{\mathit{nt}}_2})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}_2~\rightarrow~{\mathit{nt}}_1` if: |
| |
| |
| * :math:`{|{\mathit{nt}}_1|}` is of the form :math:`{|{\mathit{nt}}_2|}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}_1 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{nt}}_2})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}_2~\rightarrow~{\mathit{nt}}_1`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{load}~t~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~t` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|t|} / 8`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathsf{i}}{n}{.}\mathsf{load}}{{M}{\mathsf{\_}}{{\mathit{sx}}}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~{\mathsf{i}}{n}` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{store}~t~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~t~\rightarrow~\epsilon` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|t|} / 8`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathsf{i}}{n}{.}\mathsf{store}}{M}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~{\mathsf{i}}{n}~\rightarrow~\epsilon` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is empty. |
| |
| * The number type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The number type sequence :math:`{{\mathit{valtype}'}^\ast}` is empty. |
| |
| * Or: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is of the form :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}`. |
| |
| * The instruction :math:`{\mathit{instr}}_1` is :ref:`valid <valid-val>` with the function type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * The instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_2^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}`. |
| * Or: |
| |
| * The number type sequence :math:`{{\mathit{valtype}}^\ast}` is of the form :math:`{t^\ast}~{t_1^\ast}`. |
| |
| * The number type sequence :math:`{{\mathit{valtype}'}^\ast}` is of the form :math:`{t^\ast}~{t_2^\ast}`. |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`\epsilon` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction sequence :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_3^\ast}` if: |
| |
| |
| * The instruction :math:`{\mathit{instr}}_1` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * The instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_2^\ast}~\rightarrow~{t_3^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t^\ast}~{t_1^\ast}~\rightarrow~{t^\ast}~{t_2^\ast}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The expression :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the result type :math:`{t^?}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{t^?}`. |
| |
| |
| |
| |
| :math:`{\mathit{instr}}` is constant if: |
| |
| |
| * Either: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(t{.}\mathsf{const}~c)`. |
| |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{global{.}get}~x)`. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\epsilon~t)`. |
| |
| |
| |
| |
| :math:`(t{.}\mathsf{const}~c)` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{global{.}get}~x)` is constant if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\epsilon~t)`. |
| |
| |
| |
| |
| :math:`{{\mathit{instr}}^\ast}` is constant if: |
| |
| |
| * For all :math:`{\mathit{instr}}` in :math:`{{\mathit{instr}}^\ast}`: |
| |
| * :math:`{\mathit{instr}}` is constant. |
| |
| |
| |
| |
| The type :math:`(\mathsf{type}~{\mathit{ft}})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{ft}}` if: |
| |
| |
| * The function type :math:`{\mathit{ft}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The function :math:`(\mathsf{func}~x~{(\mathsf{local}~t)^\ast}~{\mathit{expr}})` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^?}` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[x]` is of the form :math:`{t_1^\ast}~\rightarrow~{t_2^?}`. |
| |
| * Under the context :math:`C` with the field :math:`\mathsf{locals}` appended by :math:`{t_1^\ast}~{t^\ast}` and the field :math:`\mathsf{labels}` appended by :math:`{t_2^?}` and the field :math:`\mathsf{return}` appended by :math:`{t_2^?}`, the expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the result type :math:`{t_2^?}`. |
| |
| |
| |
| |
| The global :math:`(\mathsf{global}~{\mathit{gt}}~{\mathit{expr}})` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{gt}}` if: |
| |
| |
| * The global type :math:`{\mathit{gt}}` is :ref:`valid <valid-val>`. |
| |
| * The global type :math:`{\mathit{gt}}` is of the form :math:`({\mathit{mut}}~t)`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the number type :math:`t`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The table :math:`(\mathsf{table}~{\mathit{tt}})` is :ref:`valid <valid-val>` with the table type :math:`{\mathit{tt}}` if: |
| |
| |
| * The table type :math:`{\mathit{tt}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The memory :math:`(\mathsf{memory}~{\mathit{mt}})` is :ref:`valid <valid-val>` with the memory type :math:`{\mathit{mt}}` if: |
| |
| |
| * The memory type :math:`{\mathit{mt}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The table segment :math:`(\mathsf{elem}~{\mathit{expr}}~{x^\ast})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the number type :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| * For all :math:`x` in :math:`{x^\ast}`: |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| |
| |
| |
| The memory segment :math:`(\mathsf{data}~{\mathit{expr}}~{b^\ast})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the number type :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The start function :math:`(\mathsf{start}~x)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The import :math:`(\mathsf{import}~{\mathit{name}}_1~{\mathit{name}}_2~{\mathit{xt}})` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}` if: |
| |
| |
| * The external type :math:`{\mathit{xt}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external index :math:`{\mathit{externidx}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{externtype}}` if: |
| |
| |
| * Either: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{func}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{func}~{\mathit{ft}})`. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{\mathit{ft}}`. |
| |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{global}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{global}~{\mathit{gt}})`. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`{\mathit{gt}}`. |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{table}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{table}~{\mathit{tt}})`. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`{\mathit{tt}}`. |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{mem}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{mem}~{\mathit{mt}})`. |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`{\mathit{mt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{func}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{func}~{\mathit{ft}})` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{\mathit{ft}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{global}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{global}~{\mathit{gt}})` if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`{\mathit{gt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{table}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{table}~{\mathit{tt}})` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`{\mathit{tt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{mem}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{mem}~{\mathit{mt}})` if: |
| |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`{\mathit{mt}}`. |
| |
| |
| |
| |
| The export :math:`(\mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}` if: |
| |
| |
| * The external index :math:`{\mathit{externidx}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}`. |
| |
| |
| |
| |
| The module :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` is :ref:`valid <valid-val>` if: |
| |
| |
| * For all :math:`{\mathit{type}}` in :math:`{{\mathit{type}}^\ast}`: |
| |
| * The type :math:`{\mathit{type}}` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{ft}'}`. |
| |
| * :math:`{{\mathit{ft}'}^\ast}` is the concatenation of all such :math:`{\mathit{ft}'}`. |
| |
| * For all :math:`{\mathit{import}}` in :math:`{{\mathit{import}}^\ast}`: |
| |
| * Under the context :math:`\{ \mathsf{types}~{{\mathit{ft}'}^\ast},\;\allowbreak \mathsf{return}~\epsilon \}`, the import :math:`{\mathit{import}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{ixt}}`. |
| |
| * :math:`{{\mathit{ixt}}^\ast}` is the concatenation of all such :math:`{\mathit{ixt}}`. |
| |
| * For all :math:`{\mathit{global}}` in :math:`{{\mathit{global}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the global :math:`{\mathit{global}}` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{gt}}`. |
| |
| * :math:`{{\mathit{gt}}^\ast}` is the concatenation of all such :math:`{\mathit{gt}}`. |
| |
| * For all :math:`{\mathit{func}}` in :math:`{{\mathit{func}}^\ast}`: |
| |
| * The function :math:`{\mathit{func}}` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{ft}}`. |
| |
| * :math:`{{\mathit{ft}}^\ast}` is the concatenation of all such :math:`{\mathit{ft}}`. |
| |
| * For all :math:`{\mathit{table}}` in :math:`{{\mathit{table}}^\ast}`: |
| |
| * The table :math:`{\mathit{table}}` is :ref:`valid <valid-val>` with the table type :math:`{\mathit{tt}}`. |
| |
| * :math:`{{\mathit{tt}}^\ast}` is the concatenation of all such :math:`{\mathit{tt}}`. |
| |
| * For all :math:`{\mathit{mem}}` in :math:`{{\mathit{mem}}^\ast}`: |
| |
| * The memory :math:`{\mathit{mem}}` is :ref:`valid <valid-val>` with the memory type :math:`{\mathit{mt}}`. |
| |
| * :math:`{{\mathit{mt}}^\ast}` is the concatenation of all such :math:`{\mathit{mt}}`. |
| |
| * For all :math:`{\mathit{elem}}` in :math:`{{\mathit{elem}}^\ast}`: |
| |
| * The table segment :math:`{\mathit{elem}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{data}}` in :math:`{{\mathit{data}}^\ast}`: |
| |
| * The memory segment :math:`{\mathit{data}}` is :ref:`valid <valid-val>`. |
| |
| * If :math:`{\mathit{start}}` is defined, then: |
| |
| * The start function :math:`{\mathit{start}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{export}}` in :math:`{{\mathit{export}}^\ast}`: |
| |
| * The export :math:`{\mathit{export}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}`. |
| |
| * The length of :math:`{{\mathit{tt}}^\ast}` is less than or equal to :math:`1`. |
| |
| * The length of :math:`{{\mathit{mt}}^\ast}` is less than or equal to :math:`1`. |
| |
| * The context :math:`{C'}` is of the form :math:`\{ \mathsf{types}~{{\mathit{ft}'}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{ift}}^\ast}~{{\mathit{ft}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{igt}}^\ast},\;\allowbreak \mathsf{return}~\epsilon \}`. |
| |
| * The function type sequence :math:`{{\mathit{ift}}^\ast}` is of the form :math:`{\mathrm{funcs}}({{\mathit{ixt}}^\ast})`. |
| |
| * The global type sequence :math:`{{\mathit{igt}}^\ast}` is of the form :math:`{\mathrm{globals}}({{\mathit{ixt}}^\ast})`. |
| |
| * The table type sequence :math:`{{\mathit{itt}}^\ast}` is of the form :math:`{\mathrm{tables}}({{\mathit{ixt}}^\ast})`. |
| |
| * The memory type sequence :math:`{{\mathit{imt}}^\ast}` is of the form :math:`{\mathrm{mems}}({{\mathit{ixt}}^\ast})`. |
| |
| |
| :math:`\mathsf{load}~t~{\mathit{ao}}` |
| ..................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|t|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{t}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|t|} / 8]`. |
| |
| #. Push the value :math:`(t{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}{.}\mathsf{load}}{{n}{\mathsf{\_}}{{\mathit{sx}}}}~{\mathit{ao}}` |
| ........................................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]`. |
| |
| #. Push the value :math:`({\mathsf{i}}{n}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{n, {|{\mathsf{i}}{n}|}}^{{\mathit{sx}}}}}{(c)})` to the stack. |
| |
| |
| :math:`\mathsf{store}~t~{\mathit{ao}}` |
| ...................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`t` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|t|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{t}(c)`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|t|} / 8] = {b^\ast}]`. |
| |
| |
| :math:`{{\mathsf{i}}{n}{.}\mathsf{store}}{n}~{\mathit{ao}}` |
| ........................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`{\mathsf{i}}{n}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}({{\mathrm{wrap}}}_{{|{\mathsf{i}}{n}|}, n}(c))`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8] = {b^\ast}]`. |
| |
| |
| :math:`\mathsf{unreachable}` |
| ............................ |
| |
| |
| 1. Trap. |
| |
| |
| :math:`\mathsf{nop}` |
| .................... |
| |
| |
| 1. Do nothing. |
| |
| |
| :math:`\mathsf{drop}` |
| ..................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| |
| :math:`\mathsf{select}` |
| ....................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}_2` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}_1` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Push the value :math:`{\mathit{val}}_1` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`{\mathit{val}}_2` to the stack. |
| |
| |
| :math:`\mathsf{if}~{t^?}~{{\mathit{instr}}_1^\ast}~\mathsf{else}~{{\mathit{instr}}_2^\ast}` |
| ........................................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{block}~{t^?}~{{\mathit{instr}}_1^\ast})`. |
| |
| #. Else: |
| |
| a. Execute the instruction :math:`(\mathsf{block}~{t^?}~{{\mathit{instr}}_2^\ast})`. |
| |
| |
| :math:`\mathsf{label}` |
| ...................... |
| |
| |
| 1. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| |
| :math:`\mathsf{br}~{n'}` |
| ........................ |
| |
| |
| 1. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Let :math:`L` be the topmost :math:`\mathsf{label}`. |
| |
| #. Let :math:`n` be the arity of :math:`L` |
| |
| #. If :math:`{n'} = 0`, then: |
| |
| a. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Jump to the continuation of :math:`L`. |
| |
| #. Else: |
| |
| a. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Let :math:`l` be the label index :math:`{n'} - 1`. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| |
| :math:`\mathsf{br\_if}~l` |
| ......................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. Do nothing. |
| |
| |
| :math:`\mathsf{br\_table}~{l^\ast}~{l'}` |
| ........................................ |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i < {|{l^\ast}|}`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~{l^\ast}{}[i])`. |
| |
| #. Else: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~{l'})`. |
| |
| |
| :math:`\mathsf{frame}` |
| ...................... |
| |
| |
| 1. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Let :math:`n` be the arity of :math:`f` |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{frame}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| |
| :math:`\mathsf{return}` |
| ....................... |
| |
| |
| 1. If the first non-value entry of the stack is a :math:`\mathsf{frame}`, then: |
| |
| a. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Let :math:`n` be the arity of :math:`f` |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{return}`. |
| |
| |
| :math:`t {.} {\mathit{unop}}` |
| ............................. |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`t` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{unop}}}{{}_{t}}{(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{unop}}}{{}_{t}}{(c_1)}`. |
| |
| #. Push the value :math:`(t{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`t {.} {\mathit{binop}}` |
| .............................. |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`t` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a num is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{binop}}}{{}_{t}}{(c_1, c_2)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{binop}}}{{}_{t}}{(c_1, c_2)}`. |
| |
| #. Push the value :math:`(t{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`t {.} {\mathit{testop}}` |
| ............................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`t` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{testop}}}{{}_{t}}{(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`t {.} {\mathit{relop}}` |
| .............................. |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`t` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a num is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{relop}}}{{}_{t}}{(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`t_2 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{t_1}` |
| .................................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`t_1` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{valtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{cvtop}}}{{}_{t_1, t_2}}{(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{cvtop}}}{{}_{t_1, t_2}}{(c_1)}`. |
| |
| #. Push the value :math:`(t_2{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{local{.}tee}~x` |
| .............................. |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{local{.}set}~x)`. |
| |
| |
| :math:`\mathsf{block}~{t^?}~{{\mathit{instr}}^\ast}` |
| .................................................... |
| |
| |
| 1. Let :math:`n` be :math:`0`. |
| |
| #. If :math:`{t^?}` is not defined, then: |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`n` and whose continuation is the end of the block. |
| |
| a. Enter the block :math:`{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| #. Let :math:`n` be :math:`1`. |
| |
| #. If :math:`{t^?} \neq \epsilon`, then: |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`n` and whose continuation is the end of the block. |
| |
| a. Enter the block :math:`{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{loop}~{t^?}~{{\mathit{instr}}^\ast}` |
| ................................................... |
| |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose continuation is the start of the block. |
| |
| 1. Enter the block :math:`{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{call}~x` |
| ....................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`x < {|z{.}\mathsf{module}{.}\mathsf{funcs}|}`. |
| |
| #. Execute the instruction :math:`(\mathsf{call}~z{.}\mathsf{module}{.}\mathsf{funcs}{}[x])`. |
| |
| |
| :math:`\mathsf{call\_indirect}~x` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i \geq {|z{.}\mathsf{tables}{}[0]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`z{.}\mathsf{tables}{}[0]{.}\mathsf{refs}{}[i]` is not defined, then: |
| |
| a. Trap. |
| |
| #. Let :math:`a` be :math:`z{.}\mathsf{tables}{}[0]{.}\mathsf{refs}{}[i]`. |
| |
| #. If :math:`a \geq {|z{.}\mathsf{funcs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`z{.}\mathsf{types}{}[x] \neq z{.}\mathsf{funcs}{}[a]{.}\mathsf{type}`, then: |
| |
| a. Trap. |
| |
| #. Execute the instruction :math:`(\mathsf{call}~a)`. |
| |
| |
| :math:`\mathsf{call}~a` |
| ....................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{funcs}|}`. |
| |
| #. Let :math:`\{ \mathsf{type}~{t_1^{k}}~\rightarrow~{t_2^{n}},\;\allowbreak \mathsf{module}~{\mathit{mm}},\;\allowbreak \mathsf{code}~{\mathit{func}} \}` be the destructuring of :math:`z{.}\mathsf{funcs}{}[a]`. |
| |
| #. Let :math:`(\mathsf{func}~x~{{\mathit{local}}_0^\ast}~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{func}}`. |
| |
| #. Let :math:`{t^\ast}` be the number type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{local}}_0` in :math:`{{\mathit{local}}_0^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{local}~t)` be the destructuring of :math:`{\mathit{local}}_0`. |
| |
| #. Append :math:`t` to :math:`{t^\ast}`. |
| |
| #. Assert: Due to validation, there are at least :math:`k` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{k}}` from the stack. |
| |
| #. Let :math:`f` be the frame :math:`\{ \mathsf{locals}~{{\mathit{val}}^{k}}~{{{\mathrm{default}}}_{t}^\ast},\;\allowbreak \mathsf{module}~{\mathit{mm}} \}`. |
| |
| #. Let :math:`{f'}` be the :math:`\mathsf{frame}` :math:`f` whose arity is :math:`n`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{f'}`. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`n` and whose continuation is the end of the block. |
| |
| #. Enter the block :math:`{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{local{.}get}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Push the value :math:`z{.}\mathsf{locals}{}[x]` to the stack. |
| |
| |
| :math:`\mathsf{global{.}get}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Push the value :math:`z{.}\mathsf{globals}{}[x]{.}\mathsf{value}` to the stack. |
| |
| |
| :math:`{t{.}\mathsf{load}}{{{\mathit{loadop}}^?}}~{\mathit{ao}}` |
| ................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`{{\mathit{loadop}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|t|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{t}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|t|} / 8]`. |
| |
| #. Push the value :math:`(t{.}\mathsf{const}~c)` to the stack. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`t` is :math:`{\mathsf{i}}{n}`. |
| |
| #. Let :math:`{\mathit{loadop}}_0` be :math:`{{\mathit{loadop}}^?}`. |
| |
| #. Let :math:`{n}{\mathsf{\_}}{{\mathit{sx}}}` be the destructuring of :math:`{\mathit{loadop}}_0`. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]`. |
| |
| #. Push the value :math:`(t{.}\mathsf{const}~{{{{\mathrm{extend}}}_{n, {|t|}}^{{\mathit{sx}}}}}{(c)})` to the stack. |
| |
| |
| :math:`\mathsf{memory{.}size}` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`n \cdot 64 \cdot {\mathrm{Ki}}` be the length of :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` to the stack. |
| |
| |
| :math:`\mathsf{local{.}set}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Perform :math:`z{}[{.}\mathsf{locals}{}[x] = {\mathit{val}}]`. |
| |
| |
| :math:`\mathsf{global{.}set}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Perform :math:`z{}[{.}\mathsf{globals}{}[x]{.}\mathsf{value} = {\mathit{val}}]`. |
| |
| |
| :math:`{t{.}\mathsf{store}}{{{\mathit{sz}}^?}}~{\mathit{ao}}` |
| ............................................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a num is on the top of the stack. |
| |
| #. Pop the value :math:`({t'}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, :math:`t = {t'}`. |
| |
| #. If :math:`{{\mathit{sz}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{t'}|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{t'}}(c)`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{t'}|} / 8] = {b^\ast}]`. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`{t'}` is :math:`{\mathsf{i}}{n}`. |
| |
| #. Let :math:`n` be :math:`{{\mathit{sz}}^?}`. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}({{\mathrm{wrap}}}_{{|{t'}|}, n}(c))`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8] = {b^\ast}]`. |
| |
| |
| :math:`\mathsf{memory{.}grow}` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Either: |
| |
| a. Let :math:`{\mathit{mi}}` be the memory instance :math:`{\mathrm{growmemory}}(z{.}\mathsf{mems}{}[0], n)`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|} / (64 \, {\mathrm{Ki}}))` to the stack. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0] = {\mathit{mi}}]`. |
| |
| #. Or: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{{{{\mathrm{signed}}}_{32}^{{-1}}}}{({-1})})` to the stack. |
| |
| |
| :math:`{\mathrm{Ki}}` |
| ..................... |
| |
| |
| 1. Return :math:`1024`. |
| |
| |
| :math:`{\mathrm{min}}(i, j)` |
| ............................ |
| |
| |
| 1. If :math:`i \leq j`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Return :math:`j`. |
| |
| |
| :math:`{\mathrm{sum}}({{n''}^\ast})` |
| .................................... |
| |
| |
| 1. If :math:`{{n''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`0`. |
| |
| #. Let :math:`n~{{n'}^\ast}` be :math:`{{n''}^\ast}`. |
| |
| #. Return :math:`n + {\mathrm{sum}}({{n'}^\ast})`. |
| |
| |
| :math:`{X^\ast}` |
| ................ |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{|{X^\ast}|} = 1`. |
| |
| #. Let :math:`w` be :math:`{X^\ast}`. |
| |
| #. Return :math:`w`. |
| |
| |
| :math:`{X^?}` |
| ............. |
| |
| |
| 1. If :math:`{X^?}` is not defined, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`w` be :math:`{X^?}`. |
| |
| #. Return :math:`w`. |
| |
| |
| :math:`{\mathrm{concat}}({X^\ast})` |
| ................................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{w^\ast}~{{{w'}^\ast}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{w^\ast}~{\mathrm{concat}}({{{w'}^\ast}^\ast})`. |
| |
| |
| :math:`{\mathrm{signif}}(N)` |
| ............................ |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`23`. |
| |
| #. Assert: Due to validation, :math:`N = 64`. |
| |
| #. Return :math:`52`. |
| |
| |
| :math:`{\mathrm{expon}}(N)` |
| ........................... |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`8`. |
| |
| #. Assert: Due to validation, :math:`N = 64`. |
| |
| #. Return :math:`11`. |
| |
| |
| :math:`M` |
| ......... |
| |
| |
| 1. Return :math:`{\mathrm{signif}}(N)`. |
| |
| |
| :math:`E` |
| ......... |
| |
| |
| 1. Return :math:`{\mathrm{expon}}(N)`. |
| |
| |
| :math:`{+0}` |
| ............ |
| |
| |
| 1. Return :math:`({+((0 + 0 \cdot {2^{{-M}}}) \cdot {2^{e}})})`. |
| |
| |
| :math:`{+1}` |
| ............ |
| |
| |
| 1. Return :math:`({+((1 + 1 \cdot {2^{{-M}}}) \cdot {2^{0}})})`. |
| |
| |
| :math:`{{\mathrm{canon}}}_{N}` |
| .............................. |
| |
| |
| 1. Return :math:`{2^{{\mathrm{signif}}(N) - 1}}`. |
| |
| |
| :math:`{|{\mathit{valtype}}|}` |
| .............................. |
| |
| |
| 1. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`32`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 64}}`, then: |
| |
| a. Return :math:`64`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`32`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 64}}`. |
| |
| #. Return :math:`64`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externtype}'}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{func}~{\mathit{functype}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{ft}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{ft}}~{\mathrm{funcs}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externtype}'}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{global}~{\mathit{globaltype}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{gt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{gt}}~{\mathrm{globals}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externtype}'}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{table}~{\mathit{tabletype}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{tt}}~{\mathrm{tables}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externtype}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{mem}~{\mathit{memtype}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{mt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{mt}}~{\mathrm{mems}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{xt}}^\ast})`. |
| |
| |
| |
| |
| |
| |
| 1. Return :math:`\{ \mathsf{align}~0,\;\allowbreak \mathsf{offset}~0 \}`. |
| |
| |
| :math:`\mathbb{B}(b)` |
| ..................... |
| |
| |
| 1. If :math:`b` is false, then: |
| |
| a. Return :math:`0`. |
| |
| #. Assert: Due to validation, :math:`b` is true. |
| |
| #. Return :math:`1`. |
| |
| |
| :math:`{{\mathrm{signed}}}_{N}(i)` |
| .................................. |
| |
| |
| 1. If :math:`i < {2^{N - 1}}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{2^{N - 1}} \leq i`. |
| |
| #. Assert: Due to validation, :math:`i < {2^{N}}`. |
| |
| #. Return :math:`i - {2^{N}}`. |
| |
| |
| :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{(i)}` |
| ............................................... |
| |
| |
| 1. If :math:`0 \leq i` and :math:`i < {2^{N - 1}}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{-{2^{N - 1}}} \leq i`. |
| |
| #. Assert: Due to validation, :math:`i < 0`. |
| |
| #. Return :math:`i + {2^{N}}`. |
| |
| |
| :math:`{{\mathit{unop}}}{{}_{{\mathit{valtype}}}}{({\mathit{iN}})}` |
| ................................................................... |
| |
| |
| 1. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{unop}} = \mathsf{clz}`, then: |
| |
| 1) Return :math:`{{\mathrm{iclz}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{ctz}`, then: |
| |
| 1) Return :math:`{{\mathrm{ictz}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{popcnt}`, then: |
| |
| 1) Return :math:`{{\mathrm{ipopcnt}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{abs}`, then: |
| |
| a. Return :math:`{{\mathrm{fabs}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{neg}`, then: |
| |
| a. Return :math:`{{\mathrm{fneg}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{sqrt}`, then: |
| |
| a. Return :math:`{{\mathrm{fsqrt}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{ceil}`, then: |
| |
| a. Return :math:`{{\mathrm{fceil}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{floor}`, then: |
| |
| a. Return :math:`{{\mathrm{ffloor}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{trunc}`, then: |
| |
| a. Return :math:`{{\mathrm{ftrunc}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{unop}} = \mathsf{nearest}`. |
| |
| #. Return :math:`{{\mathrm{fnearest}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}})`. |
| |
| |
| :math:`{{\mathrm{iadd}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`(i_1 + i_2) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{{{\mathrm{idiv}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................. |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_2 = 0`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Return :math:`{\mathrm{truncz}}(i_1 / i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`i_2 = 0`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i_1) / {{\mathrm{signed}}}_{N}(i_2) = {2^{N - 1}}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({\mathrm{truncz}}({{\mathrm{signed}}}_{N}(i_1) / {{\mathrm{signed}}}_{N}(i_2)))}`. |
| |
| |
| :math:`{{\mathrm{imul}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`i_1 \cdot i_2 \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{{{\mathrm{irem}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................. |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_2 = 0`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Return :math:`i_1 - i_2 \cdot {\mathrm{truncz}}(i_1 / i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`i_2 = 0`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`j_1` be :math:`{{\mathrm{signed}}}_{N}(i_1)`. |
| |
| #. Let :math:`j_2` be :math:`{{\mathrm{signed}}}_{N}(i_2)`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{(j_1 - j_2 \cdot {\mathrm{truncz}}(j_1 / j_2))}`. |
| |
| |
| :math:`{{\mathrm{isub}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`({2^{N}} + i_1 - i_2) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{\mathit{binop}}}{{}_{{\mathit{valtype}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}` |
| ....................................................................................... |
| |
| |
| 1. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{binop}} = \mathsf{add}`, then: |
| |
| 1) Return :math:`{{\mathrm{iadd}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{sub}`, then: |
| |
| 1) Return :math:`{{\mathrm{isub}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{mul}`, then: |
| |
| 1) Return :math:`{{\mathrm{imul}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{div}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{div}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{{{\mathrm{idiv}}}_{{|{\mathit{valtype}}|}}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{rem}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{rem}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{{{\mathrm{irem}}}_{{|{\mathit{valtype}}|}}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{and}`, then: |
| |
| 1) Return :math:`{{\mathrm{iand}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{or}`, then: |
| |
| 1) Return :math:`{{\mathrm{ior}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{xor}`, then: |
| |
| 1) Return :math:`{{\mathrm{ixor}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{shl}`, then: |
| |
| 1) Return :math:`{{\mathrm{ishl}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{shr}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{shr}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ishr}}}_{{|{\mathit{valtype}}|}}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{rotl}`, then: |
| |
| 1) Return :math:`{{\mathrm{irotl}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{rotr}`, then: |
| |
| 1) Return :math:`{{\mathrm{irotr}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{add}`, then: |
| |
| a. Return :math:`{{\mathrm{fadd}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{sub}`, then: |
| |
| a. Return :math:`{{\mathrm{fsub}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{mul}`, then: |
| |
| a. Return :math:`{{\mathrm{fmul}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{div}`, then: |
| |
| a. Return :math:`{{\mathrm{fdiv}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{min}`, then: |
| |
| a. Return :math:`{{\mathrm{fmin}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{max}`, then: |
| |
| a. Return :math:`{{\mathrm{fmax}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{binop}} = \mathsf{copysign}`. |
| |
| #. Return :math:`{{\mathrm{fcopysign}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| |
| :math:`{{\mathrm{ieqz}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 = 0)`. |
| |
| |
| :math:`{\mathsf{eqz}}{{}_{{\mathsf{i}}{n}}}{({\mathit{iN}})}` |
| ............................................................. |
| |
| |
| 1. Return :math:`{{\mathrm{ieqz}}}_{{|{\mathsf{i}}{n}|}}({\mathit{iN}})`. |
| |
| |
| :math:`{{\mathrm{ieq}}}_{N}(i_1, i_2)` |
| ...................................... |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 = i_2)`. |
| |
| |
| :math:`{{{{\mathrm{ige}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 \geq i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) \geq {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{{{\mathrm{igt}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 > i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) > {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{{{\mathrm{ile}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 \leq i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) \leq {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{{{\mathrm{ilt}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 < i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) < {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{\mathrm{ine}}}_{N}(i_1, i_2)` |
| ...................................... |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 \neq i_2)`. |
| |
| |
| :math:`{{\mathit{relop}}}{{}_{{\mathit{valtype}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}` |
| ....................................................................................... |
| |
| |
| 1. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{relop}} = \mathsf{eq}`, then: |
| |
| 1) Return :math:`{{\mathrm{ieq}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{ne}`, then: |
| |
| 1) Return :math:`{{\mathrm{ine}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{lt}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{lt}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ilt}}}_{{|{\mathit{valtype}}|}}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{gt}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{gt}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{igt}}}_{{|{\mathit{valtype}}|}}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{le}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{le}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ile}}}_{{|{\mathit{valtype}}|}}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{ge}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{ge}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ige}}}_{{|{\mathit{valtype}}|}}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{eq}`, then: |
| |
| a. Return :math:`{{\mathrm{feq}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{ne}`, then: |
| |
| a. Return :math:`{{\mathrm{fne}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{lt}`, then: |
| |
| a. Return :math:`{{\mathrm{flt}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{gt}`, then: |
| |
| a. Return :math:`{{\mathrm{fgt}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{le}`, then: |
| |
| a. Return :math:`{{\mathrm{fle}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{relop}} = \mathsf{ge}`. |
| |
| #. Return :math:`{{\mathrm{fge}}}_{{|{\mathit{valtype}}|}}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| |
| :math:`{{\mathit{cvtop}}}{{}_{{\mathit{valtype}}, {\mathit{valtype}'}}}{({\mathit{iN}})}` |
| ......................................................................................... |
| |
| |
| 1. If :math:`{\mathit{cvtop}}` is some :math:`\mathsf{extend}~{\mathit{sx}}`, then: |
| |
| a. Let :math:`(\mathsf{extend}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 32}}` and :math:`{\mathit{valtype}'} = \mathsf{i{\scriptstyle 64}}`, then: |
| |
| 1) Return :math:`{{{{\mathrm{extend}}}_{32, 64}^{{\mathit{sx}}}}}{({\mathit{iN}})}`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 64}}` and :math:`{\mathit{valtype}'} = \mathsf{i{\scriptstyle 32}}` and :math:`{\mathit{cvtop}} = \mathsf{wrap}`, then: |
| |
| a. Return :math:`{{\mathrm{wrap}}}_{64, 32}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{f}}{n}` and :math:`{\mathit{valtype}'}` is :math:`{\mathsf{i}}{n}` and :math:`{\mathit{cvtop}}` is some :math:`\mathsf{trunc}~{\mathit{sx}}`, then: |
| |
| a. Let :math:`(\mathsf{trunc}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #. Return :math:`{{{{\mathrm{trunc}}}_{{|{\mathit{valtype}}|}, {|{\mathit{valtype}'}|}}^{{\mathit{sx}}}}}{({\mathit{iN}})}`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 32}}` and :math:`{\mathit{valtype}'} = \mathsf{f{\scriptstyle 64}}` and :math:`{\mathit{cvtop}} = \mathsf{promote}`, then: |
| |
| a. Return :math:`{{\mathrm{promote}}}_{32, 64}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 64}}` and :math:`{\mathit{valtype}'} = \mathsf{f{\scriptstyle 32}}` and :math:`{\mathit{cvtop}} = \mathsf{demote}`, then: |
| |
| a. Return :math:`{{\mathrm{demote}}}_{64, 32}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{i}}{n}` and :math:`{\mathit{valtype}'}` is :math:`{\mathsf{f}}{n}`, then: |
| |
| a. If :math:`{\mathit{cvtop}}` is some :math:`\mathsf{convert}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{convert}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #) Return :math:`{{{{\mathrm{convert}}}_{{|{\mathit{valtype}}|}, {|{\mathit{valtype}'}|}}^{{\mathit{sx}}}}}{({\mathit{iN}})}`. |
| |
| #. If :math:`{\mathit{cvtop}} = \mathsf{reinterpret}` and :math:`{|{\mathit{valtype}}|} = {|{\mathit{valtype}'}|}`, then: |
| |
| 1) Return :math:`{{\mathrm{reinterpret}}}_{{\mathit{valtype}}, {\mathit{valtype}'}}({\mathit{iN}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}'}` is :math:`{\mathsf{i}}{n}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{cvtop}} = \mathsf{reinterpret}`. |
| |
| #. Assert: Due to validation, :math:`{|{\mathit{valtype}'}|} = {|{\mathit{valtype}}|}`. |
| |
| #. Return :math:`{{\mathrm{reinterpret}}}_{{\mathit{valtype}}, {\mathit{valtype}'}}({\mathit{iN}})`. |
| |
| |
| :math:`{{\mathrm{inez}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 \neq 0)`. |
| |
| |
| :math:`{{\mathrm{default}}}_{{\mathit{valtype}}}` |
| ................................................. |
| |
| |
| 1. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 64}}`, then: |
| |
| a. Return :math:`(\mathsf{i{\scriptstyle 64}}{.}\mathsf{const}~0)`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`(\mathsf{f{\scriptstyle 32}}{.}\mathsf{const}~{+0})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 64}}`. |
| |
| #. Return :math:`(\mathsf{f{\scriptstyle 64}}{.}\mathsf{const}~{+0})`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{func}~{\mathit{funcaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{global}~{\mathit{globaladdr}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{table}~{\mathit{tableaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{mem}~{\mathit{memaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`(s, f){.}\mathsf{store}` |
| ............................... |
| |
| |
| 1. Return. |
| |
| |
| :math:`(s, f){.}\mathsf{frame}` |
| ............................... |
| |
| |
| 1. Return :math:`f`. |
| |
| |
| :math:`(s, f){.}\mathsf{module}{.}\mathsf{funcs}` |
| ................................................. |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}{.}\mathsf{funcs}`. |
| |
| |
| :math:`(s, f){.}\mathsf{funcs}` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{funcs}`. |
| |
| |
| :math:`(s, f){.}\mathsf{globals}` |
| ................................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{globals}`. |
| |
| |
| :math:`(s, f){.}\mathsf{tables}` |
| ................................ |
| |
| |
| 1. Return :math:`s{.}\mathsf{tables}`. |
| |
| |
| :math:`(s, f){.}\mathsf{mems}` |
| .............................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{mems}`. |
| |
| |
| :math:`(s, f){.}\mathsf{module}` |
| ................................ |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}`. |
| |
| |
| :math:`(s, f){.}\mathsf{types}{}[x]` |
| .................................... |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}{.}\mathsf{types}{}[x]`. |
| |
| |
| :math:`(s, f){.}\mathsf{funcs}{}[x]` |
| .................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{funcs}{}[f{.}\mathsf{module}{.}\mathsf{funcs}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{globals}{}[x]` |
| ...................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{globals}{}[f{.}\mathsf{module}{.}\mathsf{globals}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{tables}{}[x]` |
| ..................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{mems}{}[x]` |
| ................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{locals}{}[x]` |
| ..................................... |
| |
| |
| 1. Return :math:`f{.}\mathsf{locals}{}[x]`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{locals}{}[x] = v]` |
| ............................................. |
| |
| |
| 1. Replace :math:`f{.}\mathsf{locals}{}[x]` with :math:`v`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{globals}{}[x]{.}\mathsf{value} = v]` |
| ............................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{globals}{}[f{.}\mathsf{module}{.}\mathsf{globals}{}[x]]{.}\mathsf{value}` with :math:`v`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i] = a]` |
| .................................................................. |
| |
| |
| 1. Replace :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]{.}\mathsf{refs}{}[i]` with :math:`a`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{tables}{}[x] = {\mathit{ti}}]` |
| ......................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]` with :math:`{\mathit{ti}}`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i : j] = {b^\ast}]` |
| ............................................................................ |
| |
| |
| 1. Replace :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]{.}\mathsf{bytes}{}[i : j]` with :math:`{b^\ast}`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{mems}{}[x] = {\mathit{mi}}]` |
| ....................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]` with :math:`{\mathit{mi}}`. |
| |
| |
| :math:`{\mathrm{growtable}}({\mathit{ti}}, n)` |
| .............................................. |
| |
| |
| 1. Let :math:`\{ \mathsf{type}~{}[ i .. {j^?} ],\;\allowbreak \mathsf{refs}~{a^\ast} \}` be the destructuring of :math:`{\mathit{ti}}`. |
| |
| #. Let :math:`{i'}` be :math:`{|{a^\ast}|} + n`. |
| |
| #. If :math:`{({i'} \leq j)^?}`, then: |
| |
| a. Let :math:`{\mathit{ti}'}` be the table instance :math:`\{ \mathsf{type}~{}[ {i'} .. {j^?} ],\;\allowbreak \mathsf{refs}~{a^\ast}~{\epsilon^{n}} \}`. |
| |
| #. Return :math:`{\mathit{ti}'}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{growmemory}}({\mathit{mi}}, n)` |
| ............................................... |
| |
| |
| 1. Let :math:`\{ \mathsf{type}~{}[ i .. {j^?} ],\;\allowbreak \mathsf{bytes}~{b^\ast} \}` be the destructuring of :math:`{\mathit{mi}}`. |
| |
| #. Let :math:`{i'}` be :math:`{|{b^\ast}|} / (64 \, {\mathrm{Ki}}) + n`. |
| |
| #. If :math:`{({i'} \leq j)^?}`, then: |
| |
| a. Let :math:`{\mathit{mi}'}` be the memory instance :math:`\{ \mathsf{type}~{}[ {i'} .. {j^?} ],\;\allowbreak \mathsf{bytes}~{b^\ast}~{\mathtt{0x00}^{n \cdot 64 \, {\mathrm{Ki}}}} \}`. |
| |
| #. Return :math:`{\mathit{mi}'}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externaddr}''}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{func}~{\mathit{funcaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externaddr}''}^\ast})` |
| .......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{global}~{\mathit{globaladdr}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externaddr}''}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{table}~{\mathit{tableaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externaddr}''}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{mem}~{\mathit{memaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{allocfunc}}(s, {\mathit{moduleinst}}, {\mathit{func}})` |
| ....................................................................... |
| |
| |
| 1. Let :math:`(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}})` be the destructuring of :math:`{\mathit{func}}`. |
| |
| #. Let :math:`{\mathit{fi}}` be the function instance :math:`\{ \mathsf{type}~{\mathit{moduleinst}}{.}\mathsf{types}{}[x],\;\allowbreak \mathsf{module}~{\mathit{moduleinst}},\;\allowbreak \mathsf{code}~{\mathit{func}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{funcs}`. |
| |
| #. Append :math:`{\mathit{fi}}` to :math:`s{.}\mathsf{funcs}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocfuncs}}(s, {\mathit{moduleinst}}, {{\mathit{func}''}^\ast})` |
| ................................................................................. |
| |
| |
| 1. If :math:`{{\mathit{func}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{func}}~{{\mathit{func}'}^\ast}` be :math:`{{\mathit{func}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{fa}}` be :math:`{\mathrm{allocfunc}}(s, {\mathit{moduleinst}}, {\mathit{func}})`. |
| |
| #. Let :math:`{{\mathit{fa}'}^\ast}` be :math:`{\mathrm{allocfuncs}}(s, {\mathit{moduleinst}}, {{\mathit{func}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{fa}}~{{\mathit{fa}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocglobal}}(s, {\mathit{globaltype}}, {\mathit{val}})` |
| ........................................................................ |
| |
| |
| 1. Let :math:`{\mathit{gi}}` be the global instance :math:`\{ \mathsf{type}~{\mathit{globaltype}},\;\allowbreak \mathsf{value}~{\mathit{val}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{globals}`. |
| |
| #. Append :math:`{\mathit{gi}}` to :math:`s{.}\mathsf{globals}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocglobals}}(s, {{\mathit{globaltype}''}^\ast}, {{\mathit{val}''}^\ast})` |
| ........................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{globaltype}''}^\ast} = \epsilon`, then: |
| |
| a. Assert: :math:`{{\mathit{val}''}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{globaltype}}~{{\mathit{globaltype}'}^\ast}` be :math:`{{\mathit{globaltype}''}^\ast}`. |
| |
| #. Assert: :math:`{|{{\mathit{val}''}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{val}}~{{\mathit{val}'}^\ast}` be :math:`{{\mathit{val}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ga}}` be :math:`{\mathrm{allocglobal}}(s, {\mathit{globaltype}}, {\mathit{val}})`. |
| |
| #. Let :math:`{{\mathit{ga}'}^\ast}` be :math:`{\mathrm{allocglobals}}(s, {{\mathit{globaltype}'}^\ast}, {{\mathit{val}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{ga}}~{{\mathit{ga}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{alloctable}}(s, {}[ i .. {j^?} ])` |
| .................................................. |
| |
| |
| 1. Let :math:`{\mathit{ti}}` be the table instance :math:`\{ \mathsf{type}~{}[ i .. {j^?} ],\;\allowbreak \mathsf{refs}~{\epsilon^{i}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{tables}`. |
| |
| #. Append :math:`{\mathit{ti}}` to :math:`s{.}\mathsf{tables}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{alloctables}}(s, {{\mathit{tabletype}''}^\ast})` |
| ................................................................ |
| |
| |
| 1. If :math:`{{\mathit{tabletype}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{tabletype}}~{{\mathit{tabletype}'}^\ast}` be :math:`{{\mathit{tabletype}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ta}}` be :math:`{\mathrm{alloctable}}(s, {\mathit{tabletype}})`. |
| |
| #. Let :math:`{{\mathit{ta}'}^\ast}` be :math:`{\mathrm{alloctables}}(s, {{\mathit{tabletype}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{ta}}~{{\mathit{ta}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocmem}}(s, {}[ i .. {j^?} ])` |
| ................................................ |
| |
| |
| 1. Let :math:`{\mathit{mi}}` be the memory instance :math:`\{ \mathsf{type}~{}[ i .. {j^?} ],\;\allowbreak \mathsf{bytes}~{\mathtt{0x00}^{i \cdot 64 \, {\mathrm{Ki}}}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{mems}`. |
| |
| #. Append :math:`{\mathit{mi}}` to :math:`s{.}\mathsf{mems}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocmems}}(s, {{\mathit{memtype}''}^\ast})` |
| ............................................................ |
| |
| |
| 1. If :math:`{{\mathit{memtype}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{memtype}}~{{\mathit{memtype}'}^\ast}` be :math:`{{\mathit{memtype}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ma}}` be :math:`{\mathrm{allocmem}}(s, {\mathit{memtype}})`. |
| |
| #. Let :math:`{{\mathit{ma}'}^\ast}` be :math:`{\mathrm{allocmems}}(s, {{\mathit{memtype}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{ma}}~{{\mathit{ma}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{instexport}}({{\mathit{fa}}^\ast}, {{\mathit{ga}}^\ast}, {{\mathit{ta}}^\ast}, {{\mathit{ma}}^\ast}, \mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` |
| ........................................................................................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{func}~{\mathit{funcidx}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{func}~{{\mathit{fa}}^\ast}{}[x]) \}`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{global}~{\mathit{globalidx}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{global}~{{\mathit{ga}}^\ast}{}[x]) \}`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{table}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{table}~{{\mathit{ta}}^\ast}{}[x]) \}`. |
| |
| #. Assert: :math:`{\mathit{externidx}}` is some :math:`\mathsf{mem}~{\mathit{memidx}}`. |
| |
| #. Let :math:`(\mathsf{mem}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{mem}~{{\mathit{ma}}^\ast}{}[x]) \}`. |
| |
| |
| :math:`{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}^\ast})` |
| ......................................................................................................... |
| |
| |
| 1. Let :math:`(\mathsf{module}~{{\mathit{type}}_0^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^{n_{\mathit{func}}}}~{{\mathit{global}}_1^\ast}~{{\mathit{table}}_2^\ast}~{{\mathit{mem}}_3^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be the destructuring of :math:`{\mathit{module}}`. |
| |
| #. Let :math:`{(\mathsf{memory}~{\mathit{memtype}})^{n_{\mathit{mem}}}}` be :math:`{{\mathit{mem}}_3^\ast}`. |
| |
| #. Let :math:`{(\mathsf{table}~{\mathit{tabletype}})^{n_{\mathit{table}}}}` be :math:`{{\mathit{table}}_2^\ast}`. |
| |
| #. Let :math:`{(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_1)^{n_{\mathit{global}}}}` be :math:`{{\mathit{global}}_1^\ast}`. |
| |
| #. Let :math:`{{\mathit{ft}}^\ast}` be the function type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{type}}_0` in :math:`{{\mathit{type}}_0^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{type}~{\mathit{ft}})` be the destructuring of :math:`{\mathit{type}}_0`. |
| |
| #. Append :math:`{\mathit{ft}}` to :math:`{{\mathit{ft}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{fa}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ga}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ma}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ta}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{fa}}^\ast}` be :math:`{|s{.}\mathsf{funcs}|} + i_{\mathit{func}}` for all :math:`i_{\mathit{func}}` from :math:`0` to :math:`n_{\mathit{func}} - 1`. |
| |
| #. Let :math:`{{\mathit{ga}}^\ast}` be :math:`{|s{.}\mathsf{globals}|} + i_{\mathit{global}}` for all :math:`i_{\mathit{global}}` from :math:`0` to :math:`n_{\mathit{global}} - 1`. |
| |
| #. Let :math:`{{\mathit{ta}}^\ast}` be :math:`{|s{.}\mathsf{tables}|} + i_{\mathit{table}}` for all :math:`i_{\mathit{table}}` from :math:`0` to :math:`n_{\mathit{table}} - 1`. |
| |
| #. Let :math:`{{\mathit{ma}}^\ast}` be :math:`{|s{.}\mathsf{mems}|} + i_{\mathit{mem}}` for all :math:`i_{\mathit{mem}}` from :math:`0` to :math:`n_{\mathit{mem}} - 1`. |
| |
| #. Let :math:`{{\mathit{xi}}^\ast}` be the export instance sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{export}}` in :math:`{{\mathit{export}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{xi}}` be the export instance :math:`{\mathrm{instexport}}({{\mathit{fa}}_{\mathit{ex}}^\ast}~{{\mathit{fa}}^\ast}, {{\mathit{ga}}_{\mathit{ex}}^\ast}~{{\mathit{ga}}^\ast}, {{\mathit{ta}}_{\mathit{ex}}^\ast}~{{\mathit{ta}}^\ast}, {{\mathit{ma}}_{\mathit{ex}}^\ast}~{{\mathit{ma}}^\ast}, {\mathit{export}})`. |
| |
| #. Append :math:`{\mathit{xi}}` to :math:`{{\mathit{xi}}^\ast}`. |
| |
| #. Let :math:`{\mathit{moduleinst}}` be the module instance :math:`\{ \mathsf{types}~{{\mathit{ft}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{fa}}_{\mathit{ex}}^\ast}~{{\mathit{fa}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{ga}}_{\mathit{ex}}^\ast}~{{\mathit{ga}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{ta}}_{\mathit{ex}}^\ast}~{{\mathit{ta}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{ma}}_{\mathit{ex}}^\ast}~{{\mathit{ma}}^\ast},\;\allowbreak \mathsf{exports}~{{\mathit{xi}}^\ast} \}`. |
| |
| #. Let :math:`{{\mathit{funcaddr}}_0^\ast}` be :math:`{\mathrm{allocfuncs}}(s, {\mathit{moduleinst}}, {{\mathit{func}}^{n_{\mathit{func}}}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{funcaddr}}_0^\ast} = {{\mathit{fa}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{globaladdr}}_0^\ast}` be :math:`{\mathrm{allocglobals}}(s, {{\mathit{globaltype}}^{n_{\mathit{global}}}}, {{\mathit{val}}^\ast})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{globaladdr}}_0^\ast} = {{\mathit{ga}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{tableaddr}}_0^\ast}` be :math:`{\mathrm{alloctables}}(s, {{\mathit{tabletype}}^{n_{\mathit{table}}}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{tableaddr}}_0^\ast} = {{\mathit{ta}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{memaddr}}_0^\ast}` be :math:`{\mathrm{allocmems}}(s, {{\mathit{memtype}}^{n_{\mathit{mem}}}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{memaddr}}_0^\ast} = {{\mathit{ma}}^\ast}`. |
| |
| #. Return :math:`{\mathit{moduleinst}}`. |
| |
| |
| :math:`{\mathrm{initelem}}(s, {\mathit{moduleinst}}, {{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast}, {{\mathit{funcaddr}}^\ast})` |
| .................................................................................................................................. |
| |
| |
| 1. If :math:`{{\mathit{funcaddr}}^\ast} = \epsilon`, then: |
| |
| a. Assert: :math:`{{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast} = \epsilon`. |
| |
| #. Return. |
| |
| #. Else: |
| |
| a. Let :math:`{a^\ast}~{{{a'}^\ast}^\ast}` be :math:`{{\mathit{funcaddr}}^\ast}`. |
| |
| #. Assert: :math:`{|{{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`i~{{i'}^\ast}` be :math:`{{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast}`. |
| |
| #. Replace :math:`s{.}\mathsf{tables}{}[{\mathit{moduleinst}}{.}\mathsf{tables}{}[0]]{.}\mathsf{refs}{}[i : {|{a^\ast}|}]` with :math:`{a^\ast}`. |
| |
| #. Perform :math:`{\mathrm{initelem}}(s, {\mathit{moduleinst}}, {{i'}^\ast}, {{{a'}^\ast}^\ast})`. |
| |
| #. Return. |
| |
| |
| :math:`{\mathrm{initdata}}(s, {\mathit{moduleinst}}, {{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast}, {{\mathit{byte}}^\ast})` |
| .............................................................................................................................. |
| |
| |
| 1. If :math:`{{\mathit{byte}}^\ast} = \epsilon`, then: |
| |
| a. Assert: :math:`{{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast} = \epsilon`. |
| |
| #. Return. |
| |
| #. Else: |
| |
| a. Let :math:`{b^\ast}~{{{b'}^\ast}^\ast}` be :math:`{{\mathit{byte}}^\ast}`. |
| |
| #. Assert: :math:`{|{{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`i~{{i'}^\ast}` be :math:`{{\mathit{u{\kern-0.1em\scriptstyle 32}}}^\ast}`. |
| |
| #. Replace :math:`s{.}\mathsf{mems}{}[{\mathit{moduleinst}}{.}\mathsf{mems}{}[0]]{.}\mathsf{bytes}{}[i : {|{b^\ast}|}]` with :math:`{b^\ast}`. |
| |
| #. Perform :math:`{\mathrm{initdata}}(s, {\mathit{moduleinst}}, {{i'}^\ast}, {{{b'}^\ast}^\ast})`. |
| |
| #. Return. |
| |
| |
| :math:`{\mathrm{instantiate}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast})` |
| .................................................................................. |
| |
| |
| 1. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be the destructuring of :math:`{\mathit{module}}`. |
| |
| #. Let :math:`{{\mathit{functype}}^\ast}` be the function type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{type}}` in :math:`{{\mathit{type}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{type}~{\mathit{functype}})` be the destructuring of :math:`{\mathit{type}}`. |
| |
| #. Append :math:`{\mathit{functype}}` to :math:`{{\mathit{functype}}^\ast}`. |
| |
| #. Let :math:`n_{\mathsf{f}}` be the length of :math:`{{\mathit{func}}^\ast}`. |
| |
| #. Let :math:`{{b^\ast}^\ast}` be the byte sequence sequence :math:`\epsilon`. |
| |
| #. Let :math:`{{\mathit{expr}}_{\mathsf{d}}^\ast}` be the expression sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{data}}` in :math:`{{\mathit{data}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{data}~{\mathit{expr}}_{\mathsf{d}}~{b^\ast})` be the destructuring of :math:`{\mathit{data}}`. |
| |
| #. Append :math:`{b^\ast}` to :math:`{{b^\ast}^\ast}`. |
| |
| #. Append :math:`{\mathit{expr}}_{\mathsf{d}}` to :math:`{{\mathit{expr}}_{\mathsf{d}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{expr}}_{\mathsf{e}}^\ast}` be the expression sequence :math:`\epsilon`. |
| |
| #. Let :math:`{{x^\ast}^\ast}` be the function index sequence sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{elem}}` in :math:`{{\mathit{elem}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{elem}~{\mathit{expr}}_{\mathsf{e}}~{x^\ast})` be the destructuring of :math:`{\mathit{elem}}`. |
| |
| #. Append :math:`{\mathit{expr}}_{\mathsf{e}}` to :math:`{{\mathit{expr}}_{\mathsf{e}}^\ast}`. |
| |
| #. Append :math:`{x^\ast}` to :math:`{{x^\ast}^\ast}`. |
| |
| #. Let :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}` be the expression sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{global}}` in :math:`{{\mathit{global}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_{\mathsf{g}})` be the destructuring of :math:`{\mathit{global}}`. |
| |
| #. Append :math:`{\mathit{expr}}_{\mathsf{g}}` to :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}`. |
| |
| #. Let :math:`{\mathit{moduleinst}}_{\mathit{init}}` be the module instance :math:`\{ \mathsf{types}~{{\mathit{functype}}^\ast},\;\allowbreak \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})~{({|s{.}\mathsf{funcs}|} + i_{\mathsf{f}})^{i_{\mathsf{f}}<n_{\mathsf{f}}}},\;\allowbreak \mathsf{globals}~{\mathrm{globals}}({{\mathit{externaddr}}^\ast}) \}`. |
| |
| #. Let :math:`f_{\mathit{init}}` be the frame :math:`\{ \mathsf{module}~{\mathit{moduleinst}}_{\mathit{init}} \}`. |
| |
| #. Let :math:`z` be the state :math:`(s, f_{\mathit{init}})`. |
| |
| #. Let :math:`F` be the :math:`\mathsf{frame}` :math:`z{.}\mathsf{frame}`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`F`. |
| |
| #. Let :math:`{i_{\mathsf{d}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{expr}}_{\mathsf{d}}` in :math:`{{\mathit{expr}}_{\mathsf{d}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_{\mathsf{d}})` be the result of :ref:`evaluating <exec-expr>` :math:`{\mathit{expr}}_{\mathsf{d}}` with state :math:`z`. |
| |
| #. Append :math:`i_{\mathsf{d}}` to :math:`{i_{\mathsf{d}}^\ast}`. |
| |
| #. Let :math:`{i_{\mathsf{e}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{expr}}_{\mathsf{e}}` in :math:`{{\mathit{expr}}_{\mathsf{e}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_{\mathsf{e}})` be the result of :ref:`evaluating <exec-expr>` :math:`{\mathit{expr}}_{\mathsf{e}}` with state :math:`z`. |
| |
| #. Append :math:`i_{\mathsf{e}}` to :math:`{i_{\mathsf{e}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{val}}^\ast}` be the value sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{expr}}_{\mathsf{g}}` in :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{val}}` be the result of :ref:`evaluating <exec-expr>` :math:`{\mathit{expr}}_{\mathsf{g}}` with state :math:`z`. |
| |
| #. Append :math:`{\mathit{val}}` to :math:`{{\mathit{val}}^\ast}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Let :math:`{\mathit{moduleinst}}` be :math:`{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}^\ast})`. |
| |
| #. Let :math:`f` be the frame :math:`\{ \mathsf{module}~{\mathit{moduleinst}} \}`. |
| |
| #. Perform :math:`{\mathrm{initelem}}(s, {\mathit{moduleinst}}, {i_{\mathsf{e}}^\ast}, {{{\mathit{moduleinst}}{.}\mathsf{funcs}{}[x]^\ast}^\ast})`. |
| |
| #. Perform :math:`{\mathrm{initdata}}(s, {\mathit{moduleinst}}, {i_{\mathsf{d}}^\ast}, {{b^\ast}^\ast})`. |
| |
| #. Let :math:`{f'}` be the :math:`\mathsf{frame}` :math:`f`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{f'}`. |
| |
| #. If :math:`{{\mathit{start}}^?}` is defined, then: |
| |
| a. Let :math:`(\mathsf{start}~{x'})` be :math:`{{\mathit{start}}^?}`. |
| |
| #. Let :math:`{\mathit{instr}}_0` be the administrative instruction :math:`(\mathsf{call}~{x'})`. |
| |
| #. Execute the instruction :math:`{\mathit{instr}}_0`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Return :math:`f{.}\mathsf{module}`. |
| |
| |
| :math:`{\mathrm{invoke}}(s, {\mathit{fa}}, {{\mathit{val}}^{n}})` |
| ................................................................. |
| |
| |
| 1. Let :math:`f` be the frame :math:`\{ \mathsf{module}~\{ \} \}`. |
| |
| #. Let :math:`F` be the :math:`\mathsf{frame}` :math:`(s, f)`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`F`. |
| |
| #. Let :math:`{t_1^{n}}~\rightarrow~{t_2^\ast}` be the destructuring of :math:`(s, f){.}\mathsf{funcs}{}[{\mathit{fa}}]{.}\mathsf{type}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Let :math:`k` be the length of :math:`{t_2^\ast}`. |
| |
| #. Let :math:`{f'}` be the :math:`\mathsf{frame}` :math:`f` whose arity is :math:`k`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{f'}`. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{call}~{\mathit{fa}})`. |
| |
| #. Pop the values :math:`{{\mathit{val}'}^{k}}` from the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Return :math:`{{\mathit{val}'}^{k}}`. |
| |
| |
| :math:`\mathsf{eval\_expr}~{{\mathit{instr}}^\ast}` |
| ................................................... |
| |
| |
| 1. Execute the sequence :math:`{{\mathit{instr}}^\ast}`. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Return :math:`{\mathit{val}}`. |
| |
| |
| == Complete. |
| spectec 0.5 generator |
| == Parsing... |
| == Elaboration... |
| == IL Validation... |
| == Running pass sideconditions... |
| == IL Validation after pass sideconditions... |
| == Translating to AL... |
| == Prose Generation... |
| Limits_ok |
| - the limits ([ n .. m? ]) is valid with k if: |
| - n is less than or equal to k. |
| - If m is defined, then: |
| - n is less than or equal to m. |
| - m is less than or equal to k. |
| |
| Functype_ok |
| - the function type t_1* -> t_2? is always valid. |
| |
| Globaltype_ok |
| - the global type (MUT? t) is always valid. |
| |
| Tabletype_ok |
| - the table type limits is valid if: |
| - limits is valid with ((2 ^ 32) - 1). |
| |
| Memtype_ok |
| - the memory type limits is valid if: |
| - limits is valid with (2 ^ 16). |
| |
| Externtype_ok |
| - the external type externtype is valid if: |
| - Either: |
| - externtype is (FUNC functype). |
| - the function type functype is valid. |
| - Or: |
| - externtype is (GLOBAL globaltype). |
| - the global type globaltype is valid. |
| - Or: |
| - externtype is (TABLE tabletype). |
| - the table type tabletype is valid. |
| - Or: |
| - externtype is (MEM memtype). |
| - the memory type memtype is valid. |
| |
| Externtype_ok/func |
| - the external type (FUNC functype) is valid if: |
| - the function type functype is valid. |
| |
| Externtype_ok/global |
| - the external type (GLOBAL globaltype) is valid if: |
| - the global type globaltype is valid. |
| |
| Externtype_ok/table |
| - the external type (TABLE tabletype) is valid if: |
| - the table type tabletype is valid. |
| |
| Externtype_ok/mem |
| - the external type (MEM memtype) is valid if: |
| - the memory type memtype is valid. |
| |
| Limits_sub |
| - the limits ([ n_11 .. ?(n_12) ]) matches the limits ([ n_21 .. ?(n_22) ]) if: |
| - n_11 is greater than or equal to n_21. |
| - n_12 is less than or equal to n_22. |
| |
| Functype_sub |
| - the function type ft matches only itself. |
| |
| Globaltype_sub |
| - the global type gt matches only itself. |
| |
| Tabletype_sub |
| - the table type lim_1 matches the table type lim_2 if: |
| - lim_1 matches lim_2. |
| |
| Memtype_sub |
| - the memory type lim_1 matches the memory type lim_2 if: |
| - lim_1 matches lim_2. |
| |
| Externtype_sub |
| - the external type externtype_1 matches the external type externtype_2 if: |
| - Either: |
| - externtype_1 is (FUNC ft_1). |
| - externtype_2 is (FUNC ft_2). |
| - the function type ft_1 matches the function type ft_2. |
| - Or: |
| - externtype_1 is (GLOBAL gt_1). |
| - externtype_2 is (GLOBAL gt_2). |
| - the global type gt_1 matches the global type gt_2. |
| - Or: |
| - externtype_1 is (TABLE tt_1). |
| - externtype_2 is (TABLE tt_2). |
| - the table type tt_1 matches the table type tt_2. |
| - Or: |
| - externtype_1 is (MEM mt_1). |
| - externtype_2 is (MEM mt_2). |
| - the memory type mt_1 matches the memory type mt_2. |
| |
| Externtype_sub/func |
| - the external type (FUNC ft_1) matches the external type (FUNC ft_2) if: |
| - the function type ft_1 matches the function type ft_2. |
| |
| Externtype_sub/global |
| - the external type (GLOBAL gt_1) matches the external type (GLOBAL gt_2) if: |
| - the global type gt_1 matches the global type gt_2. |
| |
| Externtype_sub/table |
| - the external type (TABLE tt_1) matches the external type (TABLE tt_2) if: |
| - the table type tt_1 matches the table type tt_2. |
| |
| Externtype_sub/mem |
| - the external type (MEM mt_1) matches the external type (MEM mt_2) if: |
| - the memory type mt_1 matches the memory type mt_2. |
| |
| Instr_ok/nop |
| - the instruction NOP is valid with the function type [] -> []. |
| |
| Instr_ok/unreachable |
| - the instruction UNREACHABLE is valid with the function type t_1* -> t_2*. |
| |
| Instr_ok/drop |
| - the instruction DROP is valid with the function type [t] -> []. |
| |
| Instr_ok/select |
| - the instruction SELECT is valid with the function type [t, t, I32] -> [t]. |
| |
| Instr_ok/block |
| - the instruction (BLOCK t? instr*) is valid with the function type [] -> t? if: |
| - the context C' is the context C with .LABELS prepended by [t?]. |
| - Under the context C', the instruction sequence instr* is valid with [] -> t?. |
| |
| Instr_ok/loop |
| - the instruction (LOOP t? instr*) is valid with the function type [] -> t? if: |
| - the context C' is the context C with .LABELS prepended by [?()]. |
| - Under the context C', the instruction sequence instr* is valid with the function type [] -> []. |
| |
| Instr_ok/if |
| - the instruction (IF t? instr_1* ELSE instr_2*) is valid with the function type [I32] -> t? if: |
| - the context C' is the context C with .LABELS prepended by [t?]. |
| - Under the context C', the instruction sequence instr_1* is valid with the function type [] -> t?. |
| - Under the context C', the instruction sequence instr_2* is valid with [] -> t?. |
| |
| Instr_ok/br |
| - the instruction (BR l) is valid with the function type t_1* :: t? -> t_2* if: |
| - the result type C.LABELS[l] exists. |
| - C.LABELS[l] is t?. |
| |
| Instr_ok/br_if |
| - the instruction (BR_IF l) is valid with the function type t? :: [I32] -> t? if: |
| - the result type C.LABELS[l] exists. |
| - C.LABELS[l] is t?. |
| |
| Instr_ok/br_table |
| - the instruction (BR_TABLE l* l') is valid with the function type t_1* :: t? :: [I32] -> t_2* if: |
| - the result type C.LABELS[l'] exists. |
| - the result type t? is C.LABELS[l']. |
| - For all l in l*: |
| - the result type C.LABELS[l] exists. |
| - t? is C.LABELS[l]. |
| |
| Instr_ok/call |
| - the instruction (CALL x) is valid with the function type t_1* -> t_2? if: |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is t_1* -> t_2?. |
| |
| Instr_ok/call_indirect |
| - the instruction (CALL_INDIRECT x) is valid with the function type t_1* :: [I32] -> t_2? if: |
| - the function type C.TYPES[x] exists. |
| - C.TYPES[x] is t_1* -> t_2?. |
| |
| Instr_ok/return |
| - the instruction RETURN is valid with the function type t_1* :: t? -> t_2* if: |
| - the result type C.RETURN is ?(t?). |
| |
| Instr_ok/const |
| - the instruction (t.CONST c_t) is valid with the function type [] -> [t]. |
| |
| Instr_ok/unop |
| - the instruction (UNOP t unop_t) is valid with the function type [t] -> [t]. |
| |
| Instr_ok/binop |
| - the instruction (BINOP t binop_t) is valid with the function type [t, t] -> [t]. |
| |
| Instr_ok/testop |
| - the instruction (TESTOP t testop_t) is valid with the function type [t] -> [I32]. |
| |
| Instr_ok/relop |
| - the instruction (RELOP t relop_t) is valid with the function type [t, t] -> [I32]. |
| |
| Instr_ok/cvtop |
| - the instruction (CVTOP nt_1 nt_2 cvtop) is valid with the function type [nt_2] -> [nt_1] if: |
| - Either: |
| - cvtop is REINTERPRET. |
| - $size(nt_1) is $size(nt_2). |
| - Or: |
| |
| |
| Instr_ok/local.get |
| - the instruction (LOCAL.GET x) is valid with the function type [] -> [t] if: |
| - the number type C.LOCALS[x] exists. |
| - C.LOCALS[x] is t. |
| |
| Instr_ok/local.set |
| - the instruction (LOCAL.SET x) is valid with the function type [t] -> [] if: |
| - the number type C.LOCALS[x] exists. |
| - C.LOCALS[x] is t. |
| |
| Instr_ok/local.tee |
| - the instruction (LOCAL.TEE x) is valid with the function type [t] -> [t] if: |
| - the number type C.LOCALS[x] exists. |
| - C.LOCALS[x] is t. |
| |
| Instr_ok/global.get |
| - the instruction (GLOBAL.GET x) is valid with the function type [] -> [t] if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (mut t). |
| |
| Instr_ok/global.set |
| - the instruction (GLOBAL.SET x) is valid with the function type [t] -> [] if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?(MUT) t). |
| |
| Instr_ok/memory.size |
| - the instruction MEMORY.SIZE is valid with the function type [] -> [I32]. |
| |
| Instr_ok/memory.grow |
| - the instruction MEMORY.GROW is valid with the function type [I32] -> [I32]. |
| |
| Instr_ok/load |
| - the instruction (LOAD t loadop_? memarg) is valid with the function type [I32] -> [t'] if: |
| - Either: |
| - loadop_? is ?(). |
| - the number type t' is t. |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(t) / 8). |
| - Or: |
| - the number type t is Inn. |
| - loadop_? is ?(M _ sx). |
| - t' is Inn. |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instr_ok/store |
| - the instruction (STORE t sz? memarg) is valid with the function type [I32, t'] -> [] if: |
| - Either: |
| - the pack size sz? is ?(). |
| - the number type t' is t. |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(t) / 8). |
| - Or: |
| - the number type t is Inn. |
| - sz? is ?(M). |
| - t' is Inn. |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instr_ok/cvtop-reinterpret |
| - the instruction (CVTOP nt_1 nt_2 REINTERPRET) is valid with the function type [nt_2] -> [nt_1] if: |
| - $size(nt_1) is $size(nt_2). |
| |
| Instr_ok/cvtop-convert |
| - the instruction (CVTOP nt_1 nt_2 cvtop) is valid with [nt_2] -> [nt_1]. |
| |
| Instr_ok/load-val |
| - the instruction (LOAD t ?() memarg) is valid with the function type [I32] -> [t] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(t) / 8). |
| |
| Instr_ok/load-pack |
| - the instruction (LOAD Inn ?(M _ sx) memarg) is valid with the function type [I32] -> [Inn] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instr_ok/store-val |
| - the instruction (STORE t ?() memarg) is valid with the function type [I32, t] -> [] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(t) / 8). |
| |
| Instr_ok/store-pack |
| - the instruction (STORE Inn ?(M) memarg) is valid with the function type [I32, Inn] -> [] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instrs_ok |
| - the instruction sequence instr* is valid with the function type valtype* -> valtype'* if: |
| - Either: |
| - instr* is []. |
| - the number type sequence valtype* is []. |
| - the number type sequence valtype'* is []. |
| - Or: |
| - instr* is [instr_1] :: instr_2*. |
| - the instruction instr_1 is valid with the function type valtype* -> t_2*. |
| - the instruction sequence instr_2* is valid with the function type t_2* -> valtype'*. |
| - Or: |
| - valtype* is t* :: t_1*. |
| - valtype'* is t* :: t_2*. |
| - instr* is valid with the function type t_1* -> t_2*. |
| |
| Instrs_ok/empty |
| - the instruction sequence [] is valid with the function type [] -> []. |
| |
| Instrs_ok/seq |
| - the instruction sequence [instr_1] :: instr_2* is valid with the function type t_1* -> t_3* if: |
| - the instruction instr_1 is valid with the function type t_1* -> t_2*. |
| - the instruction sequence instr_2* is valid with the function type t_2* -> t_3*. |
| |
| Instrs_ok/frame |
| - the instruction sequence instr* is valid with the function type t* :: t_1* -> t* :: t_2* if: |
| - instr* is valid with the function type t_1* -> t_2*. |
| |
| Expr_ok |
| - the expression instr* is valid with the result type t? if: |
| - instr* is valid with the function type [] -> t?. |
| |
| Instr_const |
| - the instruction instr is constant if: |
| - Either: |
| - instr is (t.CONST c). |
| - Or: |
| - instr is (GLOBAL.GET x). |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?() t). |
| |
| Instr_const/const |
| - the instruction (t.CONST c) is constant. |
| |
| Instr_const/global.get |
| - the instruction (GLOBAL.GET x) is constant if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?() t). |
| |
| Expr_const |
| - the expression instr* is constant if: |
| - For all instr in instr*: |
| - the instruction instr is constant. |
| |
| Type_ok |
| - the type (TYPE ft) is valid with the function type ft if: |
| - ft is valid. |
| |
| Func_ok |
| - the function (FUNC x (LOCAL t)* expr) is valid with the function type t_1* -> t_2? if: |
| - the function type C.TYPES[x] exists. |
| - C.TYPES[x] is t_1* -> t_2?. |
| - Under the context C with .LOCALS appended by t_1* :: t* and .LABELS appended by [t_2?] and .RETURN appended by ?(t_2?), the expression expr is valid with the result type t_2?. |
| |
| Global_ok |
| - the global (GLOBAL gt expr) is valid with the global type gt if: |
| - gt is valid. |
| - gt is (mut t). |
| - the expression expr is valid with the number type ?(t). |
| - expr is constant. |
| |
| Table_ok |
| - the table (TABLE tt) is valid with the table type tt if: |
| - tt is valid. |
| |
| Mem_ok |
| - the memory (MEMORY mt) is valid with the memory type mt if: |
| - mt is valid. |
| |
| Elem_ok |
| - the table segment (ELEM expr x*) is valid if: |
| - the expression expr is valid with the number type ?(I32). |
| - expr is constant. |
| - For all x in x*: |
| - the function type C.FUNCS[x] exists. |
| |
| Data_ok |
| - the memory segment (DATA expr b*) is valid if: |
| - the expression expr is valid with the number type ?(I32). |
| - expr is constant. |
| |
| Start_ok |
| - the start function (START x) is valid if: |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is [] -> []. |
| |
| Import_ok |
| - the import (IMPORT name_1 name_2 xt) is valid with the external type xt if: |
| - xt is valid. |
| |
| Externidx_ok |
| - the external index externidx is valid with the external type externtype if: |
| - Either: |
| - externidx is (FUNC x). |
| - externtype is (FUNC ft). |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is ft. |
| - Or: |
| - externidx is (GLOBAL x). |
| - externtype is (GLOBAL gt). |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is gt. |
| - Or: |
| - externidx is (TABLE x). |
| - externtype is (TABLE tt). |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is tt. |
| - Or: |
| - externidx is (MEM x). |
| - externtype is (MEM mt). |
| - the memory type C.MEMS[x] exists. |
| - C.MEMS[x] is mt. |
| |
| Externidx_ok/func |
| - the external index (FUNC x) is valid with the external type (FUNC ft) if: |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is ft. |
| |
| Externidx_ok/global |
| - the external index (GLOBAL x) is valid with the external type (GLOBAL gt) if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is gt. |
| |
| Externidx_ok/table |
| - the external index (TABLE x) is valid with the external type (TABLE tt) if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is tt. |
| |
| Externidx_ok/mem |
| - the external index (MEM x) is valid with the external type (MEM mt) if: |
| - the memory type C.MEMS[x] exists. |
| - C.MEMS[x] is mt. |
| |
| Export_ok |
| - the export (EXPORT name externidx) is valid with the external type xt if: |
| - the external index externidx is valid with xt. |
| |
| Module_ok |
| - the module (MODULE type* import* func* global* table* mem* elem* data* start? export*) is valid if: |
| - For all type in type*: |
| - the type type is valid with the function type ft'. |
| - ft'* is the concatenation of all such ft'. |
| - For all import in import*: |
| - Under the context { TYPES: ft'*; RETURN: ?() }, the import import is valid with the external type ixt. |
| - ixt* is the concatenation of all such ixt. |
| - For all global in global*: |
| - Under the context C', the global global is valid with the global type gt. |
| - gt* is the concatenation of all such gt. |
| - For all func in func*: |
| - the function func is valid with the function type ft. |
| - ft* is the concatenation of all such ft. |
| - For all table in table*: |
| - the table table is valid with the table type tt. |
| - tt* is the concatenation of all such tt. |
| - For all mem in mem*: |
| - the memory mem is valid with the memory type mt. |
| - mt* is the concatenation of all such mt. |
| - For all elem in elem*: |
| - the table segment elem is valid. |
| - For all data in data*: |
| - the memory segment data is valid. |
| - If start is defined, then: |
| - the start function start is valid. |
| - For all export in export*: |
| - the export export is valid with the external type xt. |
| - |tt*| is less than or equal to 1. |
| - |mt*| is less than or equal to 1. |
| - the context C' is { TYPES: ft'*; FUNCS: ift* :: ft*; GLOBALS: igt*; RETURN: ?() }. |
| - the function type sequence ift* is $funcsxt(ixt*). |
| - the global type sequence igt* is $globalsxt(ixt*). |
| - the table type sequence itt* is $tablesxt(ixt*). |
| - the memory type sequence imt* is $memsxt(ixt*). |
| |
| Step_read/load-num-* t ?() ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + ($size(t) / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 5. Let c be $bytes__1^-1(t, $mem(z, 0).BYTES[(i + ao.OFFSET) : ($size(t) / 8)]). |
| 6. Push the value (t.CONST c) to the stack. |
| |
| Step_read/load-pack-* Inn ?(n _ sx) ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 5. Let c be $ibytes__1^-1(n, $mem(z, 0).BYTES[(i + ao.OFFSET) : (n / 8)]). |
| 6. Push the value (Inn.CONST $extend__(n, $size(Inn), sx, c)) to the stack. |
| |
| Step/store-num-* t ?() ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type t is on the top of the stack. |
| 3. Pop the value (valtype_0.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + ($size(t) / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $bytes_(t, c). |
| 8. Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(t) / 8), b*). |
| |
| Step/store-pack-* Inn ?(n) ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type Inn is on the top of the stack. |
| 3. Pop the value (valtype_0.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)). |
| 8. Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*). |
| |
| Step_pure/unreachable |
| 1. Trap. |
| |
| Step_pure/nop |
| 1. Do nothing. |
| |
| Step_pure/drop |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| |
| Step_pure/select |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. Assert: Due to validation, a value is on the top of the stack. |
| 4. Pop the value val_2 from the stack. |
| 5. Assert: Due to validation, a value is on the top of the stack. |
| 6. Pop the value val_1 from the stack. |
| 7. If (c =/= 0), then: |
| a. Push the value val_1 to the stack. |
| 8. Else: |
| a. Push the value val_2 to the stack. |
| |
| Step_pure/if t? instr_1* instr_2* |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. If (c =/= 0), then: |
| a. Execute the instruction (BLOCK t? instr_1*). |
| 4. Else: |
| a. Execute the instruction (BLOCK t? instr_2*). |
| |
| Step_pure/label |
| 1. Pop all values val* from the top of the stack. |
| 2. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| 3. Pop the label (LABEL_ _ { _ }) from the stack. |
| 4. Push the values val* to the stack. |
| |
| Step_pure/br n' |
| 1. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| 2. Let (LABEL_ n { instr'* }) be the topmost LABEL_. |
| 3. If (n' = 0), then: |
| a. Assert: Due to validation, there are at least n values on the top of the stack. |
| b. Pop the values val^n from the stack. |
| c. Pop all values val'* from the top of the stack. |
| d. Pop the label (LABEL_ _ { _ }) from the stack. |
| e. Push the values val^n to the stack. |
| f. Execute the sequence instr'*. |
| 4. Else: |
| a. Pop all values val* from the top of the stack. |
| b. Let l be (n' - 1). |
| c. Pop the label (LABEL_ _ { _ }) from the stack. |
| d. Push the values val* to the stack. |
| e. Execute the instruction (BR l). |
| |
| Step_pure/br_if l |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. If (c =/= 0), then: |
| a. Execute the instruction (BR l). |
| 4. Else: |
| a. Do nothing. |
| |
| Step_pure/br_table l* l' |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST i) from the stack. |
| 3. If (i < |l*|), then: |
| a. Execute the instruction (BR l*[i]). |
| 4. Else: |
| a. Execute the instruction (BR l'). |
| |
| Step_pure/frame |
| 1. Let (FRAME_ n { f }) be the topmost FRAME_. |
| 2. Assert: Due to validation, there are at least n values on the top of the stack. |
| 3. Assert: Due to validation, there are at least n values on the top of the stack. |
| 4. Pop the values val^n from the stack. |
| 5. Assert: Due to validation, the first non-value entry of the stack is a FRAME_. |
| 6. Pop the frame (FRAME_ _ { _ }) from the stack. |
| 7. Push the values val^n to the stack. |
| |
| Step_pure/return |
| 1. If the first non-value entry of the stack is a FRAME_, then: |
| a. Let (FRAME_ n { f }) be the topmost FRAME_. |
| b. Assert: Due to validation, there are at least n values on the top of the stack. |
| c. Pop the values val^n from the stack. |
| d. Pop all values val'* from the top of the stack. |
| e. Pop the frame (FRAME_ _ { _ }) from the stack. |
| f. Push the values val^n to the stack. |
| 2. Else: |
| a. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| b. Pop all values val* from the top of the stack. |
| c. Pop the label (LABEL_ _ { _ }) from the stack. |
| d. Push the values val* to the stack. |
| e. Execute the instruction RETURN. |
| |
| Step_pure/unop t unop |
| 1. Assert: Due to validation, a value of value type t is on the top of the stack. |
| 2. Pop the value (valtype_0.CONST c_1) from the stack. |
| 3. If (|$unop_(t, unop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $unop_(t, unop, c_1). |
| 5. Push the value (t.CONST c) to the stack. |
| |
| Step_pure/binop t binop |
| 1. Assert: Due to validation, a value of value type t is on the top of the stack. |
| 2. Pop the value (valtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 4. Pop the value (valtype_0.CONST c_1) from the stack. |
| 5. If (|$binop_(t, binop, c_1, c_2)| <= 0), then: |
| a. Trap. |
| 6. Let c be an element of $binop_(t, binop, c_1, c_2). |
| 7. Push the value (t.CONST c) to the stack. |
| |
| Step_pure/testop t testop |
| 1. Assert: Due to validation, a value of value type t is on the top of the stack. |
| 2. Pop the value (valtype_0.CONST c_1) from the stack. |
| 3. Let c be $testop_(t, testop, c_1). |
| 4. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/relop t relop |
| 1. Assert: Due to validation, a value of value type t is on the top of the stack. |
| 2. Pop the value (valtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 4. Pop the value (valtype_0.CONST c_1) from the stack. |
| 5. Let c be $relop_(t, relop, c_1, c_2). |
| 6. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/cvtop t_2 t_1 cvtop |
| 1. Assert: Due to validation, a value of value type t_1 is on the top of the stack. |
| 2. Pop the value (valtype_0.CONST c_1) from the stack. |
| 3. If (|$cvtop__(t_1, t_2, cvtop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $cvtop__(t_1, t_2, cvtop, c_1). |
| 5. Push the value (t_2.CONST c) to the stack. |
| |
| Step_pure/local.tee x |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| 3. Push the value val to the stack. |
| 4. Push the value val to the stack. |
| 5. Execute the instruction (LOCAL.SET x). |
| |
| Step_read/block t? instr* |
| 1. Let n be 0. |
| 2. If t? is not defined, then: |
| a. Enter instr* with label (LABEL_ n { [] }). |
| 3. Let n be 1. |
| 4. If (t? =/= ?()), then: |
| a. Enter instr* with label (LABEL_ n { [] }). |
| |
| Step_read/loop t? instr* |
| 1. Enter instr* with label (LABEL_ 0 { [(LOOP t? instr*)] }). |
| |
| Step_read/call x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (x < |$funcaddr(z)|). |
| 3. Execute the instruction (CALL_ADDR $funcaddr(z)[x]). |
| |
| Step_read/call_indirect x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (i >= |$table(z, 0).REFS|), then: |
| a. Trap. |
| 5. If $table(z, 0).REFS[i] is not defined, then: |
| a. Trap. |
| 6. Let ?(a) be $table(z, 0).REFS[i]. |
| 7. If (a >= |$funcinst(z)|), then: |
| a. Trap. |
| 8. If ($type(z, x) =/= $funcinst(z)[a].TYPE), then: |
| a. Trap. |
| 9. Execute the instruction (CALL_ADDR a). |
| |
| Step_read/call_addr a |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (a < |$funcinst(z)|). |
| 3. Let { TYPE: t_1^k -> t_2^n; MODULE: mm; CODE: func } be $funcinst(z)[a]. |
| 4. Let (FUNC x local_0* instr*) be func. |
| 5. Let t* be []. |
| 6. For each local_0 in local_0*, do: |
| a. Let (LOCAL t) be local_0. |
| b. Append t to the t*. |
| 7. Assert: Due to validation, there are at least k values on the top of the stack. |
| 8. Pop the values val^k from the stack. |
| 9. Let f be { LOCALS: val^k :: $default_(t)*; MODULE: mm }. |
| 10. Push the frame (FRAME_ n { f }) to the stack. |
| 11. Enter instr* with label (LABEL_ n { [] }). |
| |
| Step_read/local.get x |
| 1. Let z be the current state. |
| 2. Push the value $local(z, x) to the stack. |
| |
| Step_read/global.get x |
| 1. Let z be the current state. |
| 2. Push the value $global(z, x).VALUE to the stack. |
| |
| Step_read/load t loadop_? ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If loadop_? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($size(t) / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| b. Let c be $bytes__1^-1(t, $mem(z, 0).BYTES[(i + ao.OFFSET) : ($size(t) / 8)]). |
| c. Push the value (t.CONST c) to the stack. |
| 5. Else: |
| a. Assert: Due to validation, t is Inn. |
| b. Let ?(loadop_0) be loadop_?. |
| c. Let n _ sx be loadop_0. |
| d. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| e. Let c be $ibytes__1^-1(n, $mem(z, 0).BYTES[(i + ao.OFFSET) : (n / 8)]). |
| f. Push the value (t.CONST $extend__(n, $size(t), sx, c)) to the stack. |
| |
| Step_read/memory.size |
| 1. Let z be the current state. |
| 2. Let ((n * 64) * $Ki()) be |$mem(z, 0).BYTES|. |
| 3. Push the value (I32.CONST n) to the stack. |
| |
| Step/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 val from the stack. |
| 4. Perform $with_local(z, x, val). |
| |
| Step/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 val from the stack. |
| 4. Perform $with_global(z, x, val). |
| |
| Step/store t sz? ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (t'.CONST c) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, (t = t'). |
| 7. If sz? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($size(t') / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| b. Let b* be $bytes_(t', c). |
| c. Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(t') / 8), b*). |
| 8. Else: |
| a. Assert: Due to validation, t' is Inn. |
| b. Let ?(n) be sz?. |
| c. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| d. Let b* be $ibytes_(n, $wrap__($size(t'), n, c)). |
| e. Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*). |
| |
| Step/memory.grow |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Either: |
| a. Let mi be $growmemory($mem(z, 0), n). |
| b. Push the value (I32.CONST (|$mem(z, 0).BYTES| / (64 * $Ki()))) to the stack. |
| c. Perform $with_meminst(z, 0, mi). |
| 5. Or: |
| a. Push the value (I32.CONST $inv_signed_(32, (- 1))) to the stack. |
| |
| Ki |
| 1. Return 1024. |
| |
| min i j |
| 1. If (i <= j), then: |
| a. Return i. |
| 2. Return j. |
| |
| sum n''* |
| 1. If (n''* = []), then: |
| a. Return 0. |
| 2. Let [n] :: n'* be n''*. |
| 3. Return (n + $sum(n'*)). |
| |
| opt_ `X X* |
| 1. If (X* = []), then: |
| a. Return ?(). |
| 2. Assert: Due to validation, (|X*| = 1). |
| 3. Let [w] be X*. |
| 4. Return ?(w). |
| |
| list_ `X X? |
| 1. If X? is not defined, then: |
| a. Return []. |
| 2. Let ?(w) be X?. |
| 3. Return [w]. |
| |
| concat_ `X X* |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w*] :: w'** be X*. |
| 3. Return w* :: $concat_(`X, w'**). |
| |
| signif N |
| 1. If (N = 32), then: |
| a. Return 23. |
| 2. Assert: Due to validation, (N = 64). |
| 3. Return 52. |
| |
| expon N |
| 1. If (N = 32), then: |
| a. Return 8. |
| 2. Assert: Due to validation, (N = 64). |
| 3. Return 11. |
| |
| M N |
| 1. Return $signif(N). |
| |
| E N |
| 1. Return $expon(N). |
| |
| fzero N |
| 1. Return (POS (SUBNORM 0)). |
| |
| fone N |
| 1. Return (POS (NORM 1 0)). |
| |
| canon_ N |
| 1. Return (2 ^ ($signif(N) - 1)). |
| |
| size valtype |
| 1. If (valtype = I32), then: |
| a. Return 32. |
| 2. If (valtype = I64), then: |
| a. Return 64. |
| 3. If (valtype = F32), then: |
| a. Return 32. |
| 4. Assert: Due to validation, (valtype = F64). |
| 5. Return 64. |
| |
| funcsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some FUNC, then: |
| a. Let (FUNC ft) be externtype_0. |
| b. Return [ft] :: $funcsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $funcsxt(xt*). |
| |
| globalsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some GLOBAL, then: |
| a. Let (GLOBAL gt) be externtype_0. |
| b. Return [gt] :: $globalsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $globalsxt(xt*). |
| |
| tablesxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some TABLE, then: |
| a. Let (TABLE tt) be externtype_0. |
| b. Return [tt] :: $tablesxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $tablesxt(xt*). |
| |
| memsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some MEM, then: |
| a. Let (MEM mt) be externtype_0. |
| b. Return [mt] :: $memsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $memsxt(xt*). |
| |
| memarg0 |
| 1. Return { ALIGN: 0; OFFSET: 0 }. |
| |
| bool b |
| 1. If (b = false), then: |
| a. Return 0. |
| 2. Assert: Due to validation, (b = true). |
| 3. Return 1. |
| |
| signed_ N i |
| 1. If (i < (2 ^ (N - 1))), then: |
| a. Return i. |
| 2. Assert: Due to validation, ((2 ^ (N - 1)) <= i). |
| 3. Assert: Due to validation, (i < (2 ^ N)). |
| 4. Return (i - (2 ^ N)). |
| |
| inv_signed_ N i |
| 1. If ((0 <= i) /\ (i < (2 ^ (N - 1)))), then: |
| a. Return i. |
| 2. Assert: Due to validation, ((- (2 ^ (N - 1))) <= i). |
| 3. Assert: Due to validation, (i < 0). |
| 4. Return (i + (2 ^ N)). |
| |
| unop_ valtype unop_ iN |
| 1. If valtype is Inn, then: |
| a. If (unop_ = CLZ), then: |
| 1) Return [$iclz_($size(valtype), iN)]. |
| b. If (unop_ = CTZ), then: |
| 1) Return [$ictz_($size(valtype), iN)]. |
| c. If (unop_ = POPCNT), then: |
| 1) Return [$ipopcnt_($size(valtype), iN)]. |
| 2. Assert: Due to validation, valtype is Fnn. |
| 3. If (unop_ = ABS), then: |
| a. Return $fabs_($size(valtype), iN). |
| 4. If (unop_ = NEG), then: |
| a. Return $fneg_($size(valtype), iN). |
| 5. If (unop_ = SQRT), then: |
| a. Return $fsqrt_($size(valtype), iN). |
| 6. If (unop_ = CEIL), then: |
| a. Return $fceil_($size(valtype), iN). |
| 7. If (unop_ = FLOOR), then: |
| a. Return $ffloor_($size(valtype), iN). |
| 8. If (unop_ = TRUNC), then: |
| a. Return $ftrunc_($size(valtype), iN). |
| 9. Assert: Due to validation, (unop_ = NEAREST). |
| 10. Return $fnearest_($size(valtype), iN). |
| |
| iadd_ N i_1 i_2 |
| 1. Return ((i_1 + i_2) \ (2 ^ N)). |
| |
| idiv_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_2 = 0), then: |
| 1) Return ?(). |
| b. Return ?($truncz((i_1 / i_2))). |
| 2. Assert: Due to validation, (sx = S). |
| 3. If (i_2 = 0), then: |
| a. Return ?(). |
| 4. If (($signed_(N, i_1) / $signed_(N, i_2)) = (2 ^ (N - 1))), then: |
| a. Return ?(). |
| 5. Return ?($inv_signed_(N, $truncz(($signed_(N, i_1) / $signed_(N, i_2))))). |
| |
| imul_ N i_1 i_2 |
| 1. Return ((i_1 * i_2) \ (2 ^ N)). |
| |
| irem_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_2 = 0), then: |
| 1) Return ?(). |
| b. Return ?((i_1 - (i_2 * $truncz((i_1 / i_2))))). |
| 2. Assert: Due to validation, (sx = S). |
| 3. If (i_2 = 0), then: |
| a. Return ?(). |
| 4. Let j_1 be $signed_(N, i_1). |
| 5. Let j_2 be $signed_(N, i_2). |
| 6. Return ?($inv_signed_(N, (j_1 - (j_2 * $truncz((j_1 / j_2)))))). |
| |
| isub_ N i_1 i_2 |
| 1. Return ((((2 ^ N) + i_1) - i_2) \ (2 ^ N)). |
| |
| binop_ valtype binop_ iN_1 iN_2 |
| 1. If valtype is Inn, then: |
| a. If (binop_ = ADD), then: |
| 1) Return [$iadd_($size(valtype), iN_1, iN_2)]. |
| b. If (binop_ = SUB), then: |
| 1) Return [$isub_($size(valtype), iN_1, iN_2)]. |
| c. If (binop_ = MUL), then: |
| 1) Return [$imul_($size(valtype), iN_1, iN_2)]. |
| d. If binop_ is some DIV, then: |
| 1) Let (DIV sx) be binop_. |
| 2) Return $list_(`val_((Inn : Inn <: valtype)), $idiv_($size(valtype), sx, iN_1, iN_2)). |
| e. If binop_ is some REM, then: |
| 1) Let (REM sx) be binop_. |
| 2) Return $list_(`val_((Inn : Inn <: valtype)), $irem_($size(valtype), sx, iN_1, iN_2)). |
| f. If (binop_ = AND), then: |
| 1) Return [$iand_($size(valtype), iN_1, iN_2)]. |
| g. If (binop_ = OR), then: |
| 1) Return [$ior_($size(valtype), iN_1, iN_2)]. |
| h. If (binop_ = XOR), then: |
| 1) Return [$ixor_($size(valtype), iN_1, iN_2)]. |
| i. If (binop_ = SHL), then: |
| 1) Return [$ishl_($size(valtype), iN_1, iN_2)]. |
| j. If binop_ is some SHR, then: |
| 1) Let (SHR sx) be binop_. |
| 2) Return [$ishr_($size(valtype), sx, iN_1, iN_2)]. |
| k. If (binop_ = ROTL), then: |
| 1) Return [$irotl_($size(valtype), iN_1, iN_2)]. |
| l. If (binop_ = ROTR), then: |
| 1) Return [$irotr_($size(valtype), iN_1, iN_2)]. |
| 2. Assert: Due to validation, valtype is Fnn. |
| 3. If (binop_ = ADD), then: |
| a. Return $fadd_($size(valtype), iN_1, iN_2). |
| 4. If (binop_ = SUB), then: |
| a. Return $fsub_($size(valtype), iN_1, iN_2). |
| 5. If (binop_ = MUL), then: |
| a. Return $fmul_($size(valtype), iN_1, iN_2). |
| 6. If (binop_ = DIV), then: |
| a. Return $fdiv_($size(valtype), iN_1, iN_2). |
| 7. If (binop_ = MIN), then: |
| a. Return $fmin_($size(valtype), iN_1, iN_2). |
| 8. If (binop_ = MAX), then: |
| a. Return $fmax_($size(valtype), iN_1, iN_2). |
| 9. Assert: Due to validation, (binop_ = COPYSIGN). |
| 10. Return $fcopysign_($size(valtype), iN_1, iN_2). |
| |
| ieqz_ N i_1 |
| 1. Return $bool((i_1 = 0)). |
| |
| testop_ Inn EQZ iN |
| 1. Return $ieqz_($size(Inn), iN). |
| |
| ieq_ N i_1 i_2 |
| 1. Return $bool((i_1 = i_2)). |
| |
| ige_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 >= i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) >= $signed_(N, i_2))). |
| |
| igt_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 > i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) > $signed_(N, i_2))). |
| |
| ile_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 <= i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) <= $signed_(N, i_2))). |
| |
| ilt_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 < i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) < $signed_(N, i_2))). |
| |
| ine_ N i_1 i_2 |
| 1. Return $bool((i_1 =/= i_2)). |
| |
| relop_ valtype relop_ iN_1 iN_2 |
| 1. If valtype is Inn, then: |
| a. If (relop_ = EQ), then: |
| 1) Return $ieq_($size(valtype), iN_1, iN_2). |
| b. If (relop_ = NE), then: |
| 1) Return $ine_($size(valtype), iN_1, iN_2). |
| c. If relop_ is some LT, then: |
| 1) Let (LT sx) be relop_. |
| 2) Return $ilt_($size(valtype), sx, iN_1, iN_2). |
| d. If relop_ is some GT, then: |
| 1) Let (GT sx) be relop_. |
| 2) Return $igt_($size(valtype), sx, iN_1, iN_2). |
| e. If relop_ is some LE, then: |
| 1) Let (LE sx) be relop_. |
| 2) Return $ile_($size(valtype), sx, iN_1, iN_2). |
| f. If relop_ is some GE, then: |
| 1) Let (GE sx) be relop_. |
| 2) Return $ige_($size(valtype), sx, iN_1, iN_2). |
| 2. Assert: Due to validation, valtype is Fnn. |
| 3. If (relop_ = EQ), then: |
| a. Return $feq_($size(valtype), iN_1, iN_2). |
| 4. If (relop_ = NE), then: |
| a. Return $fne_($size(valtype), iN_1, iN_2). |
| 5. If (relop_ = LT), then: |
| a. Return $flt_($size(valtype), iN_1, iN_2). |
| 6. If (relop_ = GT), then: |
| a. Return $fgt_($size(valtype), iN_1, iN_2). |
| 7. If (relop_ = LE), then: |
| a. Return $fle_($size(valtype), iN_1, iN_2). |
| 8. Assert: Due to validation, (relop_ = GE). |
| 9. Return $fge_($size(valtype), iN_1, iN_2). |
| |
| cvtop__ valtype valtype' cvtop iN |
| 1. If cvtop is some EXTEND, then: |
| a. Let (EXTEND sx) be cvtop. |
| b. If ((valtype = I32) /\ (valtype' = I64)), then: |
| 1) Return [$extend__(32, 64, sx, iN)]. |
| 2. If ((valtype = I64) /\ ((valtype' = I32) /\ (cvtop = WRAP))), then: |
| a. Return [$wrap__(64, 32, iN)]. |
| 3. If (valtype is Fnn /\ (valtype' is Inn /\ cvtop is some TRUNC)), then: |
| a. Let (TRUNC sx) be cvtop. |
| b. Return $list_(`val_((Inn : Inn <: valtype)), $trunc__($size(valtype), $size(valtype'), sx, iN)). |
| 4. If ((valtype = F32) /\ ((valtype' = F64) /\ (cvtop = PROMOTE))), then: |
| a. Return $promote__(32, 64, iN). |
| 5. If ((valtype = F64) /\ ((valtype' = F32) /\ (cvtop = DEMOTE))), then: |
| a. Return $demote__(64, 32, iN). |
| 6. If (valtype is Inn /\ valtype' is Fnn), then: |
| a. If cvtop is some CONVERT, then: |
| 1) Let (CONVERT sx) be cvtop. |
| 2) Return [$convert__($size(valtype), $size(valtype'), sx, iN)]. |
| b. If ((cvtop = REINTERPRET) /\ ($size(valtype) = $size(valtype'))), then: |
| 1) Return [$reinterpret__(valtype, valtype', iN)]. |
| 7. Assert: Due to validation, valtype is Fnn. |
| 8. Assert: Due to validation, valtype' is Inn. |
| 9. Assert: Due to validation, (cvtop = REINTERPRET). |
| 10. Assert: Due to validation, ($size(valtype') = $size(valtype)). |
| 11. Return [$reinterpret__(valtype, valtype', iN)]. |
| |
| inez_ N i_1 |
| 1. Return $bool((i_1 =/= 0)). |
| |
| default_ valtype |
| 1. If (valtype = I32), then: |
| a. Return (I32.CONST 0). |
| 2. If (valtype = I64), then: |
| a. Return (I64.CONST 0). |
| 3. If (valtype = F32), then: |
| a. Return (F32.CONST $fzero(32)). |
| 4. Assert: Due to validation, (valtype = F64). |
| 5. Return (F64.CONST $fzero(64)). |
| |
| funcsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some FUNC, then: |
| a. Let (FUNC fa) be externaddr_0. |
| b. Return [fa] :: $funcsxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $funcsxa(xv*). |
| |
| globalsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some GLOBAL, then: |
| a. Let (GLOBAL ga) be externaddr_0. |
| b. Return [ga] :: $globalsxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $globalsxa(xv*). |
| |
| tablesxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some TABLE, then: |
| a. Let (TABLE ta) be externaddr_0. |
| b. Return [ta] :: $tablesxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $tablesxa(xv*). |
| |
| memsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some MEM, then: |
| a. Let (MEM ma) be externaddr_0. |
| b. Return [ma] :: $memsxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $memsxa(xv*). |
| |
| store (s, f) |
| 1. Return. |
| |
| frame (s, f) |
| 1. Return f. |
| |
| funcaddr (s, f) |
| 1. Return f.MODULE.FUNCS. |
| |
| funcinst (s, f) |
| 1. Return s.FUNCS. |
| |
| globalinst (s, f) |
| 1. Return s.GLOBALS. |
| |
| tableinst (s, f) |
| 1. Return s.TABLES. |
| |
| meminst (s, f) |
| 1. Return s.MEMS. |
| |
| moduleinst (s, f) |
| 1. Return f.MODULE. |
| |
| type (s, f) x |
| 1. Return f.MODULE.TYPES[x]. |
| |
| func (s, f) x |
| 1. Return s.FUNCS[f.MODULE.FUNCS[x]]. |
| |
| global (s, f) x |
| 1. Return s.GLOBALS[f.MODULE.GLOBALS[x]]. |
| |
| table (s, f) x |
| 1. Return s.TABLES[f.MODULE.TABLES[x]]. |
| |
| mem (s, f) x |
| 1. Return s.MEMS[f.MODULE.MEMS[x]]. |
| |
| local (s, f) x |
| 1. Return f.LOCALS[x]. |
| |
| with_local (s, f) x v |
| 1. Replace f.LOCALS[x] with v. |
| |
| with_global (s, f) x v |
| 1. Replace s.GLOBALS[f.MODULE.GLOBALS[x]].VALUE with v. |
| |
| with_table (s, f) x i a |
| 1. Replace s.TABLES[f.MODULE.TABLES[x]].REFS[i] with ?(a). |
| |
| with_tableinst (s, f) x ti |
| 1. Replace s.TABLES[f.MODULE.TABLES[x]] with ti. |
| |
| with_mem (s, f) x i j b* |
| 1. Replace s.MEMS[f.MODULE.MEMS[x]].BYTES[i : j] with b*. |
| |
| with_meminst (s, f) x mi |
| 1. Replace s.MEMS[f.MODULE.MEMS[x]] with mi. |
| |
| growtable ti n |
| 1. Let { TYPE: ([ i .. j? ]); REFS: ?(a)* } be ti. |
| 2. Let i' be (|a*| + n). |
| 3. If (i' <= j)?, then: |
| a. Let ti' be { TYPE: ([ i' .. j? ]); REFS: ?(a)* :: ?()^n }. |
| b. Return ti'. |
| 4. Fail. |
| |
| growmemory mi n |
| 1. Let { TYPE: ([ i .. j? ]); BYTES: b* } be mi. |
| 2. Let i' be ((|b*| / (64 * $Ki())) + n). |
| 3. If (i' <= j)?, then: |
| a. Let mi' be { TYPE: ([ i' .. j? ]); BYTES: b* :: 0^(n * (64 * $Ki())) }. |
| b. Return mi'. |
| 4. Fail. |
| |
| funcs externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some FUNC, then: |
| a. Let (FUNC fa) be externaddr_0. |
| b. Return [fa] :: $funcs(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $funcs(externaddr'*). |
| |
| globals externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some GLOBAL, then: |
| a. Let (GLOBAL ga) be externaddr_0. |
| b. Return [ga] :: $globals(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $globals(externaddr'*). |
| |
| tables externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some TABLE, then: |
| a. Let (TABLE ta) be externaddr_0. |
| b. Return [ta] :: $tables(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $tables(externaddr'*). |
| |
| mems externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some MEM, then: |
| a. Let (MEM ma) be externaddr_0. |
| b. Return [ma] :: $mems(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $mems(externaddr'*). |
| |
| allocfunc s moduleinst func |
| 1. Let (FUNC x local* expr) be func. |
| 2. Let fi be { TYPE: moduleinst.TYPES[x]; MODULE: moduleinst; CODE: func }. |
| 3. Let a be |s.FUNCS|. |
| 4. Append fi to the s.FUNCS. |
| 5. Return a. |
| |
| allocfuncs s moduleinst func''* |
| 1. If (func''* = []), then: |
| a. Return []. |
| 2. Let [func] :: func'* be func''*. |
| 3. Let fa be $allocfunc(s, moduleinst, func). |
| 4. Let fa'* be $allocfuncs(s, moduleinst, func'*). |
| 5. Return [fa] :: fa'*. |
| |
| allocglobal s globaltype val |
| 1. Let gi be { TYPE: globaltype; VALUE: val }. |
| 2. Let a be |s.GLOBALS|. |
| 3. Append gi to the s.GLOBALS. |
| 4. Return a. |
| |
| allocglobals s globaltype''* val''* |
| 1. If (globaltype''* = []), then: |
| a. Assert: Due to validation, (val''* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [globaltype] :: globaltype'* be globaltype''*. |
| b. Assert: Due to validation, (|val''*| >= 1). |
| c. Let [val] :: val'* be val''*. |
| d. Let ga be $allocglobal(s, globaltype, val). |
| e. Let ga'* be $allocglobals(s, globaltype'*, val'*). |
| f. Return [ga] :: ga'*. |
| |
| alloctable s ([ i .. j? ]) |
| 1. Let ti be { TYPE: ([ i .. j? ]); REFS: ?()^i }. |
| 2. Let a be |s.TABLES|. |
| 3. Append ti to the s.TABLES. |
| 4. Return a. |
| |
| alloctables s tabletype''* |
| 1. If (tabletype''* = []), then: |
| a. Return []. |
| 2. Let [tabletype] :: tabletype'* be tabletype''*. |
| 3. Let ta be $alloctable(s, tabletype). |
| 4. Let ta'* be $alloctables(s, tabletype'*). |
| 5. Return [ta] :: ta'*. |
| |
| allocmem s ([ i .. j? ]) |
| 1. Let mi be { TYPE: ([ i .. j? ]); BYTES: 0^(i * (64 * $Ki())) }. |
| 2. Let a be |s.MEMS|. |
| 3. Append mi to the s.MEMS. |
| 4. Return a. |
| |
| allocmems s memtype''* |
| 1. If (memtype''* = []), then: |
| a. Return []. |
| 2. Let [memtype] :: memtype'* be memtype''*. |
| 3. Let ma be $allocmem(s, memtype). |
| 4. Let ma'* be $allocmems(s, memtype'*). |
| 5. Return [ma] :: ma'*. |
| |
| instexport fa* ga* ta* ma* (EXPORT name externidx) |
| 1. If externidx is some FUNC, then: |
| a. Let (FUNC x) be externidx. |
| b. Return { NAME: name; ADDR: (FUNC fa*[x]) }. |
| 2. If externidx is some GLOBAL, then: |
| a. Let (GLOBAL x) be externidx. |
| b. Return { NAME: name; ADDR: (GLOBAL ga*[x]) }. |
| 3. If externidx is some TABLE, then: |
| a. Let (TABLE x) be externidx. |
| b. Return { NAME: name; ADDR: (TABLE ta*[x]) }. |
| 4. Assert: Due to validation, externidx is some MEM. |
| 5. Let (MEM x) be externidx. |
| 6. Return { NAME: name; ADDR: (MEM ma*[x]) }. |
| |
| allocmodule s module externaddr* val* |
| 1. Let (MODULE type_0* import* func^n_func global_1* table_2* mem_3* elem* data* start? export*) be module. |
| 2. Let (MEMORY memtype)^n_mem be mem_3*. |
| 3. Let (TABLE tabletype)^n_table be table_2*. |
| 4. Let (GLOBAL globaltype expr_1)^n_global be global_1*. |
| 5. Let ft* be []. |
| 6. For each type_0 in type_0*, do: |
| a. Let (TYPE ft) be type_0. |
| b. Append ft to the ft*. |
| 7. Let fa_ex* be $funcs(externaddr*). |
| 8. Let ga_ex* be $globals(externaddr*). |
| 9. Let ma_ex* be $mems(externaddr*). |
| 10. Let ta_ex* be $tables(externaddr*). |
| 11. Let fa* be (|s.FUNCS| + i_func)^(i_func<n_func). |
| 12. Let ga* be (|s.GLOBALS| + i_global)^(i_global<n_global). |
| 13. Let ta* be (|s.TABLES| + i_table)^(i_table<n_table). |
| 14. Let ma* be (|s.MEMS| + i_mem)^(i_mem<n_mem). |
| 15. Let xi* be []. |
| 16. For each export in export*, do: |
| a. Let xi be $instexport(fa_ex* :: fa*, ga_ex* :: ga*, ta_ex* :: ta*, ma_ex* :: ma*, export). |
| b. Append xi to the xi*. |
| 17. Let moduleinst be { TYPES: ft*; FUNCS: fa_ex* :: fa*; GLOBALS: ga_ex* :: ga*; TABLES: ta_ex* :: ta*; MEMS: ma_ex* :: ma*; EXPORTS: xi* }. |
| 18. Let funcaddr_0* be $allocfuncs(s, moduleinst, func^n_func). |
| 19. Assert: Due to validation, (funcaddr_0* = fa*). |
| 20. Let globaladdr_0* be $allocglobals(s, globaltype^n_global, val*). |
| 21. Assert: Due to validation, (globaladdr_0* = ga*). |
| 22. Let tableaddr_0* be $alloctables(s, tabletype^n_table). |
| 23. Assert: Due to validation, (tableaddr_0* = ta*). |
| 24. Let memaddr_0* be $allocmems(s, memtype^n_mem). |
| 25. Assert: Due to validation, (memaddr_0* = ma*). |
| 26. Return moduleinst. |
| |
| initelem s moduleinst u32* funcaddr* |
| 1. If (funcaddr* = []), then: |
| a. Assert: Due to validation, (u32* = []). |
| b. Return. |
| 2. Else: |
| a. Let [a*] :: a'** be funcaddr*. |
| b. Assert: Due to validation, (|u32*| >= 1). |
| c. Let [i] :: i'* be u32*. |
| d. Replace s.TABLES[moduleinst.TABLES[0]].REFS[i : |a*|] with ?(a)*. |
| e. Perform $initelem(s, moduleinst, i'*, a'**). |
| f. Return. |
| |
| initdata s moduleinst u32* byte* |
| 1. If (byte* = []), then: |
| a. Assert: Due to validation, (u32* = []). |
| b. Return. |
| 2. Else: |
| a. Let [b*] :: b'** be byte*. |
| b. Assert: Due to validation, (|u32*| >= 1). |
| c. Let [i] :: i'* be u32*. |
| d. Replace s.MEMS[moduleinst.MEMS[0]].BYTES[i : |b*|] with b*. |
| e. Perform $initdata(s, moduleinst, i'*, b'**). |
| f. Return. |
| |
| instantiate s module externaddr* |
| 1. Let (MODULE type* import* func* global* table* mem* elem* data* start? export*) be module. |
| 2. Let functype* be []. |
| 3. For each type in type*, do: |
| a. Let (TYPE functype) be type. |
| b. Append functype to the functype*. |
| 4. Let n_F be |func*|. |
| 5. Let b** be []. |
| 6. Let expr_D* be []. |
| 7. For each data in data*, do: |
| a. Let (DATA expr_D b*) be data. |
| b. Append b* to the b**. |
| c. Append expr_D to the expr_D*. |
| 8. Let expr_E* be []. |
| 9. Let x** be []. |
| 10. For each elem in elem*, do: |
| a. Let (ELEM expr_E x*) be elem. |
| b. Append expr_E to the expr_E*. |
| c. Append x* to the x**. |
| 11. Let expr_G* be []. |
| 12. For each global in global*, do: |
| a. Let (GLOBAL globaltype expr_G) be global. |
| b. Append expr_G to the expr_G*. |
| 13. Let moduleinst_init be { TYPES: functype*; FUNCS: $funcs(externaddr*) :: (|s.FUNCS| + i_F)^(i_F<n_F); GLOBALS: $globals(externaddr*) }. |
| 14. Let f_init be { MODULE: moduleinst_init }. |
| 15. Let z be (s, f_init). |
| 16. Push the frame (FRAME_ 0 { $frame(z) }) to the stack. |
| 17. Let i_D* be []. |
| 18. For each expr_D in expr_D*, do: |
| a. Let [(I32.CONST i_D)] be $Eval_expr(z, expr_D). |
| b. Append i_D to the i_D*. |
| 19. Let i_E* be []. |
| 20. For each expr_E in expr_E*, do: |
| a. Let [(I32.CONST i_E)] be $Eval_expr(z, expr_E). |
| b. Append i_E to the i_E*. |
| 21. Let val* be []. |
| 22. For each expr_G in expr_G*, do: |
| a. Let [val] be $Eval_expr(z, expr_G). |
| b. Append val to the val*. |
| 23. Pop the frame (FRAME_ 0 { $frame(z) }) from the stack. |
| 24. Let moduleinst be $allocmodule(s, module, externaddr*, val*). |
| 25. Let f be { MODULE: moduleinst }. |
| 26. Perform $initelem(s, moduleinst, i_E*, moduleinst.FUNCS[x]**). |
| 27. Perform $initdata(s, moduleinst, i_D*, b**). |
| 28. Push the frame (FRAME_ 0 { f }) to the stack. |
| 29. If start? is defined, then: |
| a. Let ?((START x')) be start?. |
| b. Let instr_0 be (CALL x'). |
| c. Execute the instruction instr_0. |
| 30. Pop the frame (FRAME_ 0 { f }) from the stack. |
| 31. Return f.MODULE. |
| |
| invoke s fa val^n |
| 1. Let f be { MODULE: {} }. |
| 2. Push the frame (FRAME_ 0 { (s, f) }) to the stack. |
| 3. Let t_1^n -> t_2* be $funcinst((s, f))[fa].TYPE. |
| 4. Pop the frame (FRAME_ 0 { _f }) from the stack. |
| 5. Let k be |t_2*|. |
| 6. Push the frame (FRAME_ k { f }) to the stack. |
| 7. Push the values val^n to the stack. |
| 8. Execute the instruction (CALL_ADDR fa). |
| 9. Pop the values val'^k from the stack. |
| 10. Pop the frame (FRAME_ k { f }) from the stack. |
| 11. Return val'^k. |
| |
| Eval_expr instr* |
| 1. Execute the sequence instr*. |
| 2. Pop the value val from the stack. |
| 3. Return [val]. |
| |
| == Complete. |
| Generating prose for Wasm 2.0... |
| spectec 0.5 generator |
| == Parsing... |
| == Elaboration... |
| == IL Validation... |
| == Running pass sideconditions... |
| == IL Validation after pass sideconditions... |
| == Translating to AL... |
| == Prose Generation... |
| |
| |
| |
| The limits :math:`{}[ n .. {m^?} ]` is :ref:`valid <valid-val>` with :math:`k` if: |
| |
| |
| * :math:`n` is less than or equal to :math:`k`. |
| |
| * If :math:`m` is defined, then: |
| |
| * :math:`n` is less than or equal to :math:`m`. |
| |
| * :math:`m` is less than or equal to :math:`k`. |
| |
| |
| |
| |
| The function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The global type :math:`({\mathsf{mut}^?}~t)` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The table type :math:`({\mathit{limits}}~{\mathit{reftype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The limits :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` with :math:`{2^{32}} - 1`. |
| |
| |
| |
| |
| The memory type :math:`{\mathit{limits}}~\mathsf{page}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The limits :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` with :math:`{2^{16}}`. |
| |
| |
| |
| |
| The external type :math:`{\mathit{externtype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{func}~{\mathit{functype}})`. |
| |
| * The function type :math:`{\mathit{functype}}` is :ref:`valid <valid-val>`. |
| |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{global}~{\mathit{globaltype}})`. |
| |
| * The global type :math:`{\mathit{globaltype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{table}~{\mathit{tabletype}})`. |
| |
| * The table type :math:`{\mathit{tabletype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{mem}~{\mathit{memtype}})`. |
| |
| * The memory type :math:`{\mathit{memtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{func}~{\mathit{functype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The function type :math:`{\mathit{functype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{global}~{\mathit{globaltype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The global type :math:`{\mathit{globaltype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{table}~{\mathit{tabletype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The table type :math:`{\mathit{tabletype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{mem}~{\mathit{memtype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The memory type :math:`{\mathit{memtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The value type :math:`t_2` :ref:`matches <match>` the value type :math:`t_1` if: |
| |
| |
| * Either: |
| |
| * The value type :math:`t_2` is of the form :math:`t_1`. |
| |
| * Or: |
| |
| * The value type :math:`t_2` is of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The value type :math:`t` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The value type :math:`\mathsf{bot}` :ref:`matches <match>` the value type :math:`t`. |
| |
| |
| |
| |
| The result type :math:`{t_1^\ast}` :ref:`matches <match>` the result type :math:`{t_2^\ast}` if: |
| |
| |
| * For all :math:`t_1` in :math:`{t_1^\ast}`, and corresponding :math:`t_2` in :math:`{t_2^\ast}`: |
| |
| * The value type :math:`t_1` :ref:`matches <match>` the value type :math:`t_2`. |
| |
| |
| |
| |
| The limits :math:`{}[ n_{11} .. n_{12} ]` :ref:`matches <match>` the limits :math:`{}[ n_{21} .. n_{22} ]` if: |
| |
| |
| * :math:`n_{11}` is greater than or equal to :math:`n_{21}`. |
| |
| * :math:`n_{12}` is less than or equal to :math:`n_{22}`. |
| |
| |
| |
| |
| The function type :math:`{\mathit{ft}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The global type :math:`{\mathit{gt}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The table type :math:`({\mathit{lim}}_1~{\mathit{rt}})` :ref:`matches <match>` the table type :math:`({\mathit{lim}}_2~{\mathit{rt}})` if: |
| |
| |
| * The limits :math:`{\mathit{lim}}_1` :ref:`matches <match>` the limits :math:`{\mathit{lim}}_2`. |
| |
| |
| |
| |
| The memory type :math:`{\mathit{lim}}_1~\mathsf{page}` :ref:`matches <match>` the memory type :math:`{\mathit{lim}}_2~\mathsf{page}` if: |
| |
| |
| * The limits :math:`{\mathit{lim}}_1` :ref:`matches <match>` the limits :math:`{\mathit{lim}}_2`. |
| |
| |
| |
| |
| The external type :math:`{\mathit{externtype}}_1` :ref:`matches <match>` the external type :math:`{\mathit{externtype}}_2` if: |
| |
| |
| * Either: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{func}~{\mathit{ft}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{func}~{\mathit{ft}}_2)`. |
| |
| * The function type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the function type :math:`{\mathit{ft}}_2`. |
| |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{global}~{\mathit{gt}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{global}~{\mathit{gt}}_2)`. |
| |
| * The global type :math:`{\mathit{gt}}_1` :ref:`matches <match>` the global type :math:`{\mathit{gt}}_2`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{table}~{\mathit{tt}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{table}~{\mathit{tt}}_2)`. |
| |
| * The table type :math:`{\mathit{tt}}_1` :ref:`matches <match>` the table type :math:`{\mathit{tt}}_2`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{mem}~{\mathit{mt}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{mem}~{\mathit{mt}}_2)`. |
| |
| * The memory type :math:`{\mathit{mt}}_1` :ref:`matches <match>` the memory type :math:`{\mathit{mt}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{func}~{\mathit{ft}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{func}~{\mathit{ft}}_2)` if: |
| |
| |
| * The function type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the function type :math:`{\mathit{ft}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{global}~{\mathit{gt}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{global}~{\mathit{gt}}_2)` if: |
| |
| |
| * The global type :math:`{\mathit{gt}}_1` :ref:`matches <match>` the global type :math:`{\mathit{gt}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{table}~{\mathit{tt}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{table}~{\mathit{tt}}_2)` if: |
| |
| |
| * The table type :math:`{\mathit{tt}}_1` :ref:`matches <match>` the table type :math:`{\mathit{tt}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{mem}~{\mathit{mt}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{mem}~{\mathit{mt}}_2)` if: |
| |
| |
| * The memory type :math:`{\mathit{mt}}_1` :ref:`matches <match>` the memory type :math:`{\mathit{mt}}_2`. |
| |
| |
| |
| |
| The block type :math:`{\mathit{blocktype}}` is :ref:`valid <valid-val>` with the function type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The block type :math:`{\mathit{blocktype}}` is of the form :math:`{{\mathit{valtype}''}^?}`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The value type sequence :math:`{{\mathit{valtype}'}^\ast}` is of the form :math:`{{\mathit{valtype}''}^?}`. |
| |
| * Or: |
| |
| * The block type :math:`{\mathit{blocktype}}` is of the form :math:`{\mathit{typeidx}}`. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` is of the form :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}`. |
| |
| |
| |
| |
| The block type :math:`{{\mathit{valtype}}^?}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{{\mathit{valtype}}^?}`. |
| |
| |
| |
| |
| The block type :math:`{\mathit{typeidx}}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` is of the form :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{nop}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{unreachable}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{drop}` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{select}~{{\mathit{valtype}}^?})` is :ref:`valid <valid-val>` with the function type :math:`t~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~t` if: |
| |
| |
| * Either: |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^?}` is of the form :math:`t`. |
| |
| * Or: |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^?}` is absent. |
| |
| * The value type :math:`t` :ref:`matches <match>` the value type :math:`{t'}`. |
| |
| * The value type :math:`{t'}` is of the form :math:`{\mathit{numtype}}` or :math:`{t'}` is of the form :math:`{\mathit{vectype}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{bt}}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_2^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{loop}~{\mathit{bt}}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{bt}}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_1^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{if}~{\mathit{bt}}~{{\mathit{instr}}_1^\ast}~\mathsf{else}~{{\mathit{instr}}_2^\ast})` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{bt}}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_2^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}_1^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br}~l)` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~{t^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_if}~l)` is :ref:`valid <valid-val>` with the function type :math:`{t^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t^\ast}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_table}~{l^\ast}~{l'})` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~{t^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * For all :math:`l` in :math:`{l^\ast}`: |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`{t^\ast}` :ref:`matches <match>` the result type :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| * The result type :math:`C{.}\mathsf{labels}{}[{l'}]` exists. |
| |
| * The result type :math:`{t^\ast}` :ref:`matches <match>` the result type :math:`C{.}\mathsf{labels}{}[{l'}]`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{call}~x)` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{call\_indirect}~x~y)` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~\mathsf{funcref})`. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[y]` exists. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[y]` is of the form :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{return}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~{t^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{return}` is of the form :math:`{t^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}{.}\mathsf{const}~c_{\mathit{nt}})` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{\mathit{nt}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{unop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}~\rightarrow~{\mathit{nt}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{binop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}~{\mathit{nt}}~\rightarrow~{\mathit{nt}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{testop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{relop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}~{\mathit{nt}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}_1 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{nt}}_2})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}_2~\rightarrow~{\mathit{nt}}_1` if: |
| |
| |
| * Either: |
| |
| * :math:`{\mathit{cvtop}}` is of the form :math:`\mathsf{reinterpret}`. |
| |
| * :math:`{|{\mathit{nt}}_1|}` is of the form :math:`{|{\mathit{nt}}_2|}`. |
| |
| * Or: |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{ref{.}null}~{\mathit{rt}})` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{\mathit{rt}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{ref{.}func}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\mathsf{funcref}` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{ref{.}is\_null}` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{rt}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvunop}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvbinop}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvternop}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvtestop}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vunop}}_{\mathit{sh}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vbinop}}_{\mathit{sh}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vtestop}}_{\mathit{sh}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vrelop}}_{\mathit{sh}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vshiftop}}_{\mathit{sh}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{bitmask})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{swizzle})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{shuffle}~{i^\ast})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * For all :math:`i` in :math:`{i^\ast}`: |
| |
| * The lane index :math:`i` is less than :math:`2 \cdot {\mathrm{dim}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{splat})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{numtype}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The number type :math:`{\mathit{numtype}}` is :math:`{\mathrm{unpack}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{sh}}{.}\mathsf{extract\_lane}}{{{\mathit{sx}}^?}}~i)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~{\mathit{numtype}}` if: |
| |
| |
| * The lane index :math:`i` is less than :math:`{\mathrm{dim}}({\mathit{sh}})`. |
| |
| * The number type :math:`{\mathit{numtype}}` is :math:`{\mathrm{unpack}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{replace\_lane}~i)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~{\mathit{numtype}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The lane index :math:`i` is less than :math:`{\mathrm{dim}}({\mathit{sh}})`. |
| |
| * The number type :math:`{\mathit{numtype}}` is :math:`{\mathrm{unpack}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{vextunop}~{\mathit{sh}}_1~{\mathit{sh}}_2~{\mathit{vextunop}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{vextbinop}~{\mathit{sh}}_1~{\mathit{sh}}_2~{\mathit{vextbinop}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{sh}}_1{.}\mathsf{narrow}}{\mathsf{\_}}{{\mathit{sh}}_2}{\mathsf{\_}}{{\mathit{sx}}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}_1 {.} {{\mathit{vcvtop}}}{\mathsf{\_}}{{\mathit{sh}}_2})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}get}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~t` if: |
| |
| |
| * The value type :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The value type :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}set}~x)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~\epsilon` if: |
| |
| |
| * The value type :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The value type :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}tee}~x)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~t` if: |
| |
| |
| * The value type :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The value type :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{global{.}get}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~t` if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`({\mathit{mut}}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{global{.}set}~x)` is :ref:`valid <valid-val>` with the function type :math:`t~\rightarrow~\epsilon` if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\mathsf{mut}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}get}~x)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~{\mathit{rt}}` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}set}~x)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~{\mathit{rt}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}size}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\mathsf{i{\scriptstyle 32}}` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}grow}~x)` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{rt}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{i{\scriptstyle 32}}` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}fill}~x)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~{\mathit{rt}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}copy}~x_1~x_2)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x_1]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x_1]` is of the form :math:`({\mathit{lim}}_1~{\mathit{rt}})`. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x_2]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x_2]` is of the form :math:`({\mathit{lim}}_2~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}init}~x_1~x_2)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x_1]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x_1]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| * The element type :math:`C{.}\mathsf{elems}{}[x_2]` exists. |
| |
| * The reference type :math:`C{.}\mathsf{elems}{}[x_2]` is of the form :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{elem{.}drop}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\epsilon` if: |
| |
| |
| * The element type :math:`C{.}\mathsf{elems}{}[x]` exists. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{memory{.}size}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{memory{.}grow}` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{memory{.}fill}` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{memory{.}copy}` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{memory{.}init}~x)` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The data type :math:`C{.}\mathsf{datas}{}[x]` exists. |
| |
| * The data type :math:`C{.}\mathsf{datas}{}[x]` is of the form :math:`\mathsf{ok}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{data{.}drop}~x)` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\epsilon` if: |
| |
| |
| * The data type :math:`C{.}\mathsf{datas}{}[x]` exists. |
| |
| * The data type :math:`C{.}\mathsf{datas}{}[x]` is of the form :math:`\mathsf{ok}`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{nt}}{.}\mathsf{load}}{{{\mathit{loadop}}^?}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~{\mathit{valtype}}` if: |
| |
| |
| * Either: |
| |
| * :math:`{{\mathit{loadop}}^?}` is absent. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{nt}}`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|{\mathit{nt}}|} / 8`. |
| |
| * Or: |
| |
| * The number type :math:`{\mathit{nt}}` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * :math:`{{\mathit{loadop}}^?}` is of the form :math:`{M}{\mathsf{\_}}{{\mathit{sx}}}`. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{nt}}{.}\mathsf{store}}{{{\mathit{sz}}^?}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~{\mathit{valtype}}~\rightarrow~\epsilon` if: |
| |
| |
| * Either: |
| |
| * The pack size :math:`{{\mathit{sz}}^?}` is absent. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{nt}}`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|{\mathit{nt}}|} / 8`. |
| |
| * Or: |
| |
| * The number type :math:`{\mathit{nt}}` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * The pack size :math:`{{\mathit{sz}}^?}` is of the form :math:`M`. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathsf{i}}{n}`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~{\mathit{vloadop}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * Either: |
| |
| * :math:`{\mathit{vloadop}}` is of the form :math:`({M}{\mathsf{x}}{N}{\mathsf{\_}}{{\mathit{sx}}})`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8 \cdot N`. |
| |
| * Or: |
| |
| * :math:`{\mathit{vloadop}}` is of the form :math:`({n}{\mathsf{\_}}{\mathsf{splat}})`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`n / 8`. |
| * Or: |
| |
| * :math:`{\mathit{vloadop}}` is of the form :math:`({n}{\mathsf{\_}}{\mathsf{zero}})`. |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`n / 8`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{vload\_lane}~\mathsf{v{\scriptstyle 128}}~n~{\mathit{memarg}}~{\mathit{laneidx}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`n / 8`. |
| |
| * :math:`{\mathit{laneidx}}` is less than :math:`128 / n`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{vstore}~\mathsf{v{\scriptstyle 128}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\epsilon` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|\mathsf{v{\scriptstyle 128}}|} / 8`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{vstore\_lane}~\mathsf{v{\scriptstyle 128}}~n~{\mathit{memarg}}~{\mathit{laneidx}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\epsilon` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`n / 8`. |
| |
| * :math:`{\mathit{laneidx}}` is less than :math:`128 / n`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{select}~t)` is :ref:`valid <valid-val>` with the function type :math:`t~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~t`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{select})` is :ref:`valid <valid-val>` with the function type :math:`t~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~t` if: |
| |
| |
| * The value type :math:`t` :ref:`matches <match>` the value type :math:`{t'}`. |
| |
| * The value type :math:`{t'}` is of the form :math:`{\mathit{numtype}}` or :math:`{t'}` is of the form :math:`{\mathit{vectype}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}_1 {.} {\mathsf{reinterpret}}{\mathsf{\_}}{{\mathit{nt}}_2})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}_2~\rightarrow~{\mathit{nt}}_1` if: |
| |
| |
| * :math:`{|{\mathit{nt}}_1|}` is of the form :math:`{|{\mathit{nt}}_2|}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}_1 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{nt}}_2})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{nt}}_2~\rightarrow~{\mathit{nt}}_1`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{load}~{\mathit{nt}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~{\mathit{nt}}` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|{\mathit{nt}}|} / 8`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathsf{i}}{n}{.}\mathsf{load}}{{M}{\mathsf{\_}}{{\mathit{sx}}}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~{\mathsf{i}}{n}` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{store}~{\mathit{nt}}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~{\mathit{nt}}~\rightarrow~\epsilon` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`{|{\mathit{nt}}|} / 8`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathsf{i}}{n}{.}\mathsf{store}}{M}~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~{\mathsf{i}}{n}~\rightarrow~\epsilon` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~({M}{\mathsf{x}}{N}{\mathsf{\_}}{{\mathit{sx}}})~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`M / 8 \cdot N`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~({n}{\mathsf{\_}}{\mathsf{splat}})~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`n / 8`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~({n}{\mathsf{\_}}{\mathsf{zero}})~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the function type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * :math:`{2^{{\mathit{memarg}}{.}\mathsf{align}}}` is less than or equal to :math:`n / 8`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is empty. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The value type sequence :math:`{{\mathit{valtype}'}^\ast}` is empty. |
| |
| * Or: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is of the form :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}`. |
| |
| * The instruction :math:`{\mathit{instr}}_1` is :ref:`valid <valid-val>` with the function type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * The instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_2^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}`. |
| * Or: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * The result type :math:`{{\mathit{valtype}}^\ast}` :ref:`matches <match>` the result type :math:`{t_1^\ast}`. |
| |
| * The result type :math:`{t_2^\ast}` :ref:`matches <match>` the result type :math:`{{\mathit{valtype}'}^\ast}`. |
| * Or: |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is of the form :math:`{t^\ast}~{t_1^\ast}`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}'}^\ast}` is of the form :math:`{t^\ast}~{t_2^\ast}`. |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`\epsilon` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction sequence :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_3^\ast}` if: |
| |
| |
| * The instruction :math:`{\mathit{instr}}_1` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * The instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_2^\ast}~\rightarrow~{t_3^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{{t'}_1^\ast}~\rightarrow~{{t'}_2^\ast}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * The result type :math:`{{t'}_1^\ast}` :ref:`matches <match>` the result type :math:`{t_1^\ast}`. |
| |
| * The result type :math:`{t_2^\ast}` :ref:`matches <match>` the result type :math:`{{t'}_2^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t^\ast}~{t_1^\ast}~\rightarrow~{t^\ast}~{t_2^\ast}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| |
| |
| The expression :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the result type :math:`{t^\ast}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the function type :math:`\epsilon~\rightarrow~{t^\ast}`. |
| |
| |
| |
| |
| :math:`{\mathit{instr}}` is constant if: |
| |
| |
| * Either: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({\mathit{nt}}{.}\mathsf{const}~c)`. |
| |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({\mathit{vt}}{.}\mathsf{const}~{\mathit{vc}})`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{ref{.}null}~{\mathit{rt}})`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{ref{.}func}~x)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{global{.}get}~x)`. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\epsilon~t)`. |
| |
| |
| |
| |
| :math:`({\mathit{nt}}{.}\mathsf{const}~c)` is constant. |
| |
| |
| |
| |
| :math:`({\mathit{vt}}{.}\mathsf{const}~{\mathit{vc}})` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{ref{.}null}~{\mathit{rt}})` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{ref{.}func}~x)` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{global{.}get}~x)` is constant if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\epsilon~t)`. |
| |
| |
| |
| |
| :math:`{{\mathit{instr}}^\ast}` is constant if: |
| |
| |
| * For all :math:`{\mathit{instr}}` in :math:`{{\mathit{instr}}^\ast}`: |
| |
| * :math:`{\mathit{instr}}` is constant. |
| |
| |
| |
| |
| The type :math:`(\mathsf{type}~{\mathit{ft}})` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{ft}}` if: |
| |
| |
| * The function type :math:`{\mathit{ft}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The function :math:`(\mathsf{func}~x~{(\mathsf{local}~t)^\ast}~{\mathit{expr}})` is :ref:`valid <valid-val>` with the function type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{types}{}[x]` is of the form :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * For all :math:`t` in :math:`{t^\ast}`: |
| |
| * The value type :math:`t` is not of the form :math:`\mathsf{bot}`. |
| |
| * Under the context :math:`C` with the field :math:`\mathsf{locals}` appended by :math:`{t_1^\ast}~{t^\ast}` and the field :math:`\mathsf{labels}` appended by :math:`{t_2^\ast}` and the field :math:`\mathsf{return}` appended by :math:`{t_2^\ast}`, the expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the result type :math:`{t_2^\ast}`. |
| |
| |
| |
| |
| The global :math:`(\mathsf{global}~{\mathit{gt}}~{\mathit{expr}})` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{gt}}` if: |
| |
| |
| * The global type :math:`{\mathit{gt}}` is :ref:`valid <valid-val>`. |
| |
| * The global type :math:`{\mathit{gt}}` is of the form :math:`({\mathit{mut}}~t)`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The table :math:`(\mathsf{table}~{\mathit{tt}})` is :ref:`valid <valid-val>` with the table type :math:`{\mathit{tt}}` if: |
| |
| |
| * The table type :math:`{\mathit{tt}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The memory :math:`(\mathsf{memory}~{\mathit{mt}})` is :ref:`valid <valid-val>` with the memory type :math:`{\mathit{mt}}` if: |
| |
| |
| * The memory type :math:`{\mathit{mt}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| :math:`{\mathit{elemmode}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}` if: |
| |
| |
| * Either: |
| |
| * :math:`{\mathit{elemmode}}` is of the form :math:`(\mathsf{active}~x~{\mathit{expr}})`. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| * Or: |
| |
| * :math:`{\mathit{elemmode}}` is of the form :math:`\mathsf{passive}`. |
| * Or: |
| |
| * :math:`{\mathit{elemmode}}` is of the form :math:`\mathsf{declare}`. |
| |
| |
| |
| |
| :math:`(\mathsf{active}~x~{\mathit{expr}})` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{lim}}~{\mathit{rt}})`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| :math:`\mathsf{passive}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| :math:`\mathsf{declare}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The table segment :math:`(\mathsf{elem}~{\mathit{rt}}~{{\mathit{expr}}^\ast}~{\mathit{elemmode}})` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}` if: |
| |
| |
| * For all :math:`{\mathit{expr}}` in :math:`{{\mathit{expr}}^\ast}`: |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{rt}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| * :math:`{\mathit{elemmode}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| :math:`{\mathit{datamode}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * :math:`{\mathit{datamode}}` is of the form :math:`(\mathsf{active}~0~{\mathit{expr}})`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| * Or: |
| |
| * :math:`{\mathit{datamode}}` is of the form :math:`\mathsf{passive}`. |
| |
| |
| |
| |
| :math:`(\mathsf{active}~0~{\mathit{expr}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| :math:`\mathsf{passive}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The memory segment :math:`(\mathsf{data}~{b^\ast}~{\mathit{datamode}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * :math:`{\mathit{datamode}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The start function :math:`(\mathsf{start}~x)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The import :math:`(\mathsf{import}~{\mathit{name}}_1~{\mathit{name}}_2~{\mathit{xt}})` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}` if: |
| |
| |
| * The external type :math:`{\mathit{xt}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external index :math:`{\mathit{externidx}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{externtype}}` if: |
| |
| |
| * Either: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{func}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{func}~{\mathit{ft}})`. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{\mathit{ft}}`. |
| |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{global}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{global}~{\mathit{gt}})`. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`{\mathit{gt}}`. |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{table}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{table}~{\mathit{tt}})`. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`{\mathit{tt}}`. |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{mem}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{mem}~{\mathit{mt}})`. |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`{\mathit{mt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{func}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{func}~{\mathit{ft}})` if: |
| |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function type :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{\mathit{ft}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{global}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{global}~{\mathit{gt}})` if: |
| |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global type :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`{\mathit{gt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{table}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{table}~{\mathit{tt}})` if: |
| |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table type :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`{\mathit{tt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{mem}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{mem}~{\mathit{mt}})` if: |
| |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory type :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`{\mathit{mt}}`. |
| |
| |
| |
| |
| The export :math:`(\mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}` if: |
| |
| |
| * The external index :math:`{\mathit{externidx}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}`. |
| |
| |
| |
| |
| The module :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^{n}}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` is :ref:`valid <valid-val>` if: |
| |
| |
| * For all :math:`{\mathit{type}}` in :math:`{{\mathit{type}}^\ast}`: |
| |
| * The type :math:`{\mathit{type}}` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{ft}'}`. |
| |
| * :math:`{{\mathit{ft}'}^\ast}` is the concatenation of all such :math:`{\mathit{ft}'}`. |
| |
| * For all :math:`{\mathit{import}}` in :math:`{{\mathit{import}}^\ast}`: |
| |
| * Under the context :math:`\{ \mathsf{types}~{{\mathit{ft}'}^\ast},\;\allowbreak \mathsf{return}~\epsilon \}`, the import :math:`{\mathit{import}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{ixt}}`. |
| |
| * :math:`{{\mathit{ixt}}^\ast}` is the concatenation of all such :math:`{\mathit{ixt}}`. |
| |
| * For all :math:`{\mathit{global}}` in :math:`{{\mathit{global}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the global :math:`{\mathit{global}}` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{gt}}`. |
| |
| * :math:`{{\mathit{gt}}^\ast}` is the concatenation of all such :math:`{\mathit{gt}}`. |
| |
| * For all :math:`{\mathit{table}}` in :math:`{{\mathit{table}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the table :math:`{\mathit{table}}` is :ref:`valid <valid-val>` with the table type :math:`{\mathit{tt}}`. |
| |
| * :math:`{{\mathit{tt}}^\ast}` is the concatenation of all such :math:`{\mathit{tt}}`. |
| |
| * For all :math:`{\mathit{mem}}` in :math:`{{\mathit{mem}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the memory :math:`{\mathit{mem}}` is :ref:`valid <valid-val>` with the memory type :math:`{\mathit{mt}}`. |
| |
| * :math:`{{\mathit{mt}}^\ast}` is the concatenation of all such :math:`{\mathit{mt}}`. |
| |
| * For all :math:`{\mathit{elem}}` in :math:`{{\mathit{elem}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the table segment :math:`{\mathit{elem}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| * :math:`{{\mathit{rt}}^\ast}` is the concatenation of all such :math:`{\mathit{rt}}`. |
| |
| * For all :math:`{\mathit{data}}` in :math:`{{\mathit{data}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the memory segment :math:`{\mathit{data}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{func}}` in :math:`{{\mathit{func}}^\ast}`: |
| |
| * The function :math:`{\mathit{func}}` is :ref:`valid <valid-val>` with the function type :math:`{\mathit{ft}}`. |
| |
| * :math:`{{\mathit{ft}}^\ast}` is the concatenation of all such :math:`{\mathit{ft}}`. |
| |
| * If :math:`{\mathit{start}}` is defined, then: |
| |
| * The start function :math:`{\mathit{start}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{export}}` in :math:`{{\mathit{export}}^\ast}`: |
| |
| * The export :math:`{\mathit{export}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}`. |
| |
| * The length of :math:`{{\mathit{mt}}^\ast}` is less than or equal to :math:`1`. |
| |
| * The context :math:`{C'}` is of the form :math:`\{ \mathsf{types}~{{\mathit{ft}'}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{ift}}^\ast}~{{\mathit{ft}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{igt}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{itt}}^\ast}~{{\mathit{tt}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{imt}}^\ast}~{{\mathit{mt}}^\ast},\;\allowbreak \mathsf{return}~\epsilon \}`. |
| |
| * The function type sequence :math:`{{\mathit{ift}}^\ast}` is of the form :math:`{\mathrm{funcs}}({{\mathit{ixt}}^\ast})`. |
| |
| * The global type sequence :math:`{{\mathit{igt}}^\ast}` is of the form :math:`{\mathrm{globals}}({{\mathit{ixt}}^\ast})`. |
| |
| * The table type sequence :math:`{{\mathit{itt}}^\ast}` is of the form :math:`{\mathrm{tables}}({{\mathit{ixt}}^\ast})`. |
| |
| * The memory type sequence :math:`{{\mathit{imt}}^\ast}` is of the form :math:`{\mathrm{mems}}({{\mathit{ixt}}^\ast})`. |
| |
| |
| :math:`\mathsf{table{.}copy}~x~y` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{tables}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`\mathsf{table{.}init}~x~y` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`\mathsf{load}~{\mathit{nt}}~{\mathit{ao}}` |
| ................................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8]`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}{.}\mathsf{load}}{{n}{\mathsf{\_}}{{\mathit{sx}}}}~{\mathit{ao}}` |
| ........................................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]`. |
| |
| #. Push the value :math:`({\mathsf{i}}{n}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{n, {|{\mathsf{i}}{n}|}}^{{\mathit{sx}}}}}{(c)})` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~({M}{\mathsf{x}}{N}{\mathsf{\_}}{{\mathit{sx}}})~{\mathit{ao}}` |
| ................................................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + M \cdot N / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{j^{N}}` be the result for which :math:`{({{\mathrm{bytes}}}_{{\mathsf{i}}{M}}({j^{N}}) = z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} + k \cdot M / 8 : M / 8])^{k<N}}`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`M \cdot 2`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}({{{{{\mathrm{extend}}}_{M, {|{\mathsf{i}}{n}|}}^{{\mathit{sx}}}}}{(j)}^{N}})`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~({N}{\mathsf{\_}}{\mathsf{splat}})~{\mathit{ao}}` |
| ..................................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`M` be :math:`128 / N`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`N`. |
| |
| #. Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({j^{M}})`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~({N}{\mathsf{\_}}{\mathsf{zero}})~{\mathit{ao}}` |
| .................................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #. Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{N, 128}^{\mathsf{u}}}}{(j)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{memory{.}copy}` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`\mathsf{memory{.}init}~x` |
| ................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{datas}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`\mathsf{store}~{\mathit{nt}}~{\mathit{ao}}` |
| .................................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8] = {b^\ast}]`. |
| |
| |
| :math:`{{\mathsf{i}}{n}{.}\mathsf{store}}{n}~{\mathit{ao}}` |
| ........................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`{\mathsf{i}}{n}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}({{\mathrm{wrap}}}_{{|{\mathsf{i}}{n}|}, n}(c))`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8] = {b^\ast}]`. |
| |
| |
| :math:`\mathsf{unreachable}` |
| ............................ |
| |
| |
| 1. Trap. |
| |
| |
| :math:`\mathsf{nop}` |
| .................... |
| |
| |
| 1. Do nothing. |
| |
| |
| :math:`\mathsf{drop}` |
| ..................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| |
| :math:`\mathsf{select}~{({t^\ast})^?}` |
| ...................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}_2` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}_1` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Push the value :math:`{\mathit{val}}_1` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`{\mathit{val}}_2` to the stack. |
| |
| |
| :math:`\mathsf{if}~{\mathit{bt}}~{{\mathit{instr}}_1^\ast}~\mathsf{else}~{{\mathit{instr}}_2^\ast}` |
| ................................................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}_1^\ast})`. |
| |
| #. Else: |
| |
| a. Execute the instruction :math:`(\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}_2^\ast})`. |
| |
| |
| :math:`\mathsf{label}` |
| ...................... |
| |
| |
| 1. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| |
| :math:`\mathsf{br}~{n'}` |
| ........................ |
| |
| |
| 1. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Let :math:`L` be the topmost :math:`\mathsf{label}`. |
| |
| #. Let :math:`n` be the arity of :math:`L` |
| |
| #. If :math:`{n'} = 0`, then: |
| |
| a. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Jump to the continuation of :math:`L`. |
| |
| #. Else: |
| |
| a. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Let :math:`l` be the label index :math:`{n'} - 1`. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| |
| :math:`\mathsf{br\_if}~l` |
| ......................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. Do nothing. |
| |
| |
| :math:`\mathsf{br\_table}~{l^\ast}~{l'}` |
| ........................................ |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i < {|{l^\ast}|}`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~{l^\ast}{}[i])`. |
| |
| #. Else: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~{l'})`. |
| |
| |
| :math:`\mathsf{frame}` |
| ...................... |
| |
| |
| 1. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Let :math:`n` be the arity of :math:`f` |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{frame}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| |
| :math:`\mathsf{return}` |
| ....................... |
| |
| |
| 1. If the first non-value entry of the stack is a :math:`\mathsf{frame}`, then: |
| |
| a. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Let :math:`n` be the arity of :math:`f` |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{return}`. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{unop}}` |
| ......................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{unop}}}{{}_{{\mathit{nt}}}}{(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{unop}}}{{}_{{\mathit{nt}}}}{(c_1)}`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{binop}}` |
| .......................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a number is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{binop}}}{{}_{{\mathit{nt}}}}{(c_1, c_2)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{binop}}}{{}_{{\mathit{nt}}}}{(c_1, c_2)}`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{testop}}` |
| ........................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{testop}}}{{}_{{\mathit{nt}}}}{(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{relop}}` |
| .......................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a number is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{relop}}}{{}_{{\mathit{nt}}}}{(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}}_2 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{nt}}_1}` |
| ............................................................................ |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}_1` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{cvtop}}}{{}_{{\mathit{nt}}_1, {\mathit{nt}}_2}}{(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{cvtop}}}{{}_{{\mathit{nt}}_1, {\mathit{nt}}_2}}{(c_1)}`. |
| |
| #. Push the value :math:`({\mathit{nt}}_2{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{ref{.}is\_null}` |
| ............................... |
| |
| |
| 1. Assert: Due to validation, a reference is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. If :math:`{\mathit{ref}}` is some :math:`\mathsf{ref{.}null}~{\mathit{reftype}}`, then: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvunop}}` |
| .......................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vvunop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvbinop}}` |
| ........................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vvbinop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvternop}}` |
| ............................................................ |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_3)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vvternop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1, c_2, c_3)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} \mathsf{any\_true}` |
| ........................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{ine}}}_{{|\mathsf{v{\scriptstyle 128}}|}}(c_1, 0)`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vunop}}` |
| .......................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{vunop}}}{{}_{{\mathit{sh}}}}{(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vunop}}}{{}_{{\mathit{sh}}}}{(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vbinop}}` |
| ........................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{vbinop}}}{{}_{{\mathit{sh}}}}{(c_1, c_2)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vbinop}}}{{}_{{\mathit{sh}}}}{(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}}{\mathsf{x}}{N} {.} \mathsf{all\_true}` |
| ............................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Let :math:`{{\mathit{ci}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}(c)`. |
| |
| #. If :math:`{({\mathit{ci}}_1 \neq 0)^\ast}`, then: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vrelop}}` |
| ........................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vrelop}}}{{}_{{\mathit{sh}}}}{(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}}{\mathsf{x}}{N} {.} {\mathit{vshiftop}}` |
| ................................................................ |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`{{c'}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}(c_1)`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}({{{{\mathit{vshiftop}}}{\mathsf{\_}}~{{\mathsf{i}}{n}}{\mathsf{x}}{N}}{({c'}, n)}^\ast})`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}}{\mathsf{x}}{N}{.}\mathsf{bitmask}` |
| ........................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Let :math:`{{\mathit{ci}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}(c)`. |
| |
| #. Let :math:`{\mathit{ci}}` be the result for which :math:`{{\mathrm{bits}}}_{{\mathsf{i}}{32}}({\mathit{ci}})` :math:`=` :math:`{{{{{\mathrm{ilt}}}_{{|{\mathsf{i}}{n}|}}^{\mathsf{s}}}}{({\mathit{ci}}_1, 0)}^\ast}~{0^{32 - N}}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{{\mathrm{irev}}}_{32}({\mathit{ci}}))` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}}{\mathsf{x}}{M}{.}\mathsf{swizzle}` |
| ........................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`{{c'}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}(c_1)~{0^{256 - M}}`. |
| |
| #. Let :math:`{{\mathit{ci}}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}(c_2)`. |
| |
| #. Assert: Due to validation, :math:`{({{\mathit{ci}}^\ast}{}[k] < {|{{c'}^\ast}|})^{k<M}}`. |
| |
| #. Assert: Due to validation, :math:`{(k < {|{{\mathit{ci}}^\ast}|})^{k<M}}`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{{c'}^\ast}{}[{{\mathit{ci}}^\ast}{}[k]]^{k<M}})`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}}{\mathsf{x}}{N}{.}\mathsf{shuffle}~{i^\ast}` |
| .................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{(k < {|{i^\ast}|})^{k<N}}`. |
| |
| #. Let :math:`{{c'}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}(c_1)~{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}(c_2)`. |
| |
| #. Assert: Due to validation, :math:`{({i^\ast}{}[k] < {|{{c'}^\ast}|})^{k<N}}`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}({{{c'}^\ast}{}[{i^\ast}{}[k]]^{k<N}})`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}}{\mathsf{x}}{N}{.}\mathsf{splat}` |
| ......................................................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}_0 = {\mathrm{unpack}}({\mathsf{i}}{n})`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}({{{\mathrm{pack}}}_{{\mathsf{i}}{n}}(c_1)^{N}})`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{{\mathit{lanetype}}}{\mathsf{x}}{N}{.}\mathsf{extract\_lane}}{{{\mathit{sx}'}^?}}~i` |
| ............................................................................................. |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{sx}'}^?}` is not defined, then: |
| |
| a. Assert: Due to validation, :math:`{\mathit{lanetype}}` is number type. |
| |
| #. Assert: Due to validation, :math:`i < {|{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{N}}(c_1)|}`. |
| |
| #. Let :math:`c_2` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{N}}(c_1){}[i]`. |
| |
| #. Push the value :math:`({\mathit{lanetype}}{.}\mathsf{const}~c_2)` to the stack. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Let :math:`{\mathit{sx}}` be :math:`{{\mathit{sx}'}^?}`. |
| |
| #. Assert: Due to validation, :math:`i < {|{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{N}}(c_1)|}`. |
| |
| #. Let :math:`c_2` be :math:`{{{{\mathrm{extend}}}_{{|{\mathit{lanetype}}|}, 32}^{{\mathit{sx}}}}}{({{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{N}}(c_1){}[i])}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c_2)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{n}}{\mathsf{x}}{N}{.}\mathsf{replace\_lane}~i` |
| ................................................................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}_0 = {\mathrm{unpack}}({\mathsf{i}}{n})`. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}({{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}(c_1){}[{}[i] = {{\mathrm{pack}}}_{{\mathsf{i}}{n}}(c_2)])`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{vextunop}~{\mathit{sh}}_1~{\mathit{sh}}_2~{\mathit{vextunop}}` |
| ............................................................................. |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{vextunop}}}_{{\mathit{sh}}_1, {\mathit{sh}}_2}({\mathit{vextunop}}, c_1)`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{vextbinop}~{\mathit{sh}}_1~{\mathit{sh}}_2~{\mathit{vextbinop}}` |
| ............................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{vextbinop}}}_{{\mathit{sh}}_1, {\mathit{sh}}_2}({\mathit{vextbinop}}, c_1, c_2)`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{N_2}{.}\mathsf{narrow}}{\mathsf{\_}}{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{N_1}}{\mathsf{\_}}{{\mathit{sx}}}` |
| ................................................................................................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`{{\mathit{ci}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{N_1}}(c_1)`. |
| |
| #. Let :math:`{{\mathit{ci}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{N_1}}(c_2)`. |
| |
| #. Let :math:`{{\mathit{cj}}_1^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{ci}}_1` in :math:`{{\mathit{ci}}_1^\ast}`, do: |
| |
| a. Let :math:`{\mathit{cj}}_1` be :math:`{{{{\mathrm{narrow}}}_{{|{{\mathsf{i}}{n}}_1|}, {|{{\mathsf{i}}{n}}_2|}}^{{\mathit{sx}}}}}{{\mathit{ci}}_1}`. |
| |
| #. Append :math:`{\mathit{cj}}_1` to :math:`{{\mathit{cj}}_1^\ast}`. |
| |
| #. Let :math:`{{\mathit{cj}}_2^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{ci}}_2` in :math:`{{\mathit{ci}}_2^\ast}`, do: |
| |
| a. Let :math:`{\mathit{cj}}_2` be :math:`{{{{\mathrm{narrow}}}_{{|{{\mathsf{i}}{n}}_1|}, {|{{\mathsf{i}}{n}}_2|}}^{{\mathit{sx}}}}}{{\mathit{ci}}_2}`. |
| |
| #. Append :math:`{\mathit{cj}}_2` to :math:`{{\mathit{cj}}_2^\ast}`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{N_2}}({{\mathit{cj}}_1^\ast}~{{\mathit{cj}}_2^\ast})`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M} {.} {{\mathit{vcvtop}}}{\mathsf{\_}}{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{{M'}}}` |
| .......................................................................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{\mathrm{halfop}}({\mathit{vcvtop}})` is defined, then: |
| |
| a. Let :math:`{\mathit{half}}` be :math:`{\mathrm{halfop}}({\mathit{vcvtop}})`. |
| |
| #. Let :math:`{{\mathit{ci}}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{{M'}}}(c_1){}[{\mathrm{half}}({\mathit{half}}, 0, M) : M]`. |
| |
| #. Let :math:`{{{\mathit{cj}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{vcvtop}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{{M'}}, {{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M}}({\mathit{vcvtop}}, {\mathit{ci}})^\ast}`. |
| |
| #. If :math:`{|{{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M}}({{\mathit{cj}}^\ast})^\ast}|} > 0`, then: |
| |
| 1) Let :math:`c` be an element of :math:`{{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M}}({{\mathit{cj}}^\ast})^\ast}`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. Else if :math:`{\mathrm{zeroop}}({\mathit{vcvtop}})` is not defined and :math:`M = {M'}`, then: |
| |
| a. Let :math:`{{\mathit{ci}}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{{M'}}}(c_1)`. |
| |
| #. Let :math:`{{{\mathit{cj}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{vcvtop}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{{M'}}, {{{\mathsf{i}}{n}}_2}{\mathsf{x}}{{M'}}}({\mathit{vcvtop}}, {\mathit{ci}})^\ast}`. |
| |
| #. If :math:`{|{{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{{M'}}}({{\mathit{cj}}^\ast})^\ast}|} > 0`, then: |
| |
| 1) Let :math:`c` be an element of :math:`{{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{{M'}}}({{\mathit{cj}}^\ast})^\ast}`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. If :math:`{\mathrm{zeroop}}({\mathit{vcvtop}}) = \mathsf{zero}` and :math:`{{\mathsf{i}}{n}}_1` is number type and :math:`{{\mathsf{i}}{n}}_2` is number type, then: |
| |
| a. Let :math:`{{\mathit{ci}}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{{M'}}}(c_1)`. |
| |
| #. Let :math:`{{{\mathit{cj}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{vcvtop}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{{M'}}, {{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M}}({\mathit{vcvtop}}, {\mathit{ci}})^\ast}~{{\mathrm{zero}}({{\mathsf{i}}{n}}_2)^{{M'}}}`. |
| |
| #. If :math:`{|{{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M}}({{\mathit{cj}}^\ast})^\ast}|} > 0`, then: |
| |
| 1) Let :math:`c` be an element of :math:`{{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M}}({{\mathit{cj}}^\ast})^\ast}`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{local{.}tee}~x` |
| .............................. |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{local{.}set}~x)`. |
| |
| |
| :math:`\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}^\ast}` |
| ............................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`{t_1^{k}}~\rightarrow~{t_2^{n}}` be the destructuring of :math:`{{\mathrm{blocktype}}}_{z}({\mathit{bt}})`. |
| |
| #. Assert: Due to validation, there are at least :math:`k` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{k}}` from the stack. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`n` and whose continuation is the end of the block. |
| |
| #. Enter the block :math:`{{\mathit{val}}^{k}}~{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{loop}~{\mathit{bt}}~{{\mathit{instr}}^\ast}` |
| ........................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`{t_1^{k}}~\rightarrow~{t_2^{n}}` be the destructuring of :math:`{{\mathrm{blocktype}}}_{z}({\mathit{bt}})`. |
| |
| #. Assert: Due to validation, there are at least :math:`k` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{k}}` from the stack. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`k` and whose continuation is the start of the block. |
| |
| #. Enter the block :math:`{{\mathit{val}}^{k}}~{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{call}~x` |
| ....................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`x < {|z{.}\mathsf{module}{.}\mathsf{funcs}|}`. |
| |
| #. Execute the instruction :math:`(\mathsf{call}~z{.}\mathsf{module}{.}\mathsf{funcs}{}[x])`. |
| |
| |
| :math:`\mathsf{call\_indirect}~x~y` |
| ................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i \geq {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i]` is not some :math:`\mathsf{ref{.}func\_addr}~{\mathit{funcaddr}}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`(\mathsf{ref{.}func\_addr}~a)` be the destructuring of :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i]`. |
| |
| #. If :math:`a \geq {|z{.}\mathsf{funcs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`z{.}\mathsf{types}{}[y] \neq z{.}\mathsf{funcs}{}[a]{.}\mathsf{type}`, then: |
| |
| a. Trap. |
| |
| #. Execute the instruction :math:`(\mathsf{call}~a)`. |
| |
| |
| :math:`\mathsf{call}~a` |
| ....................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{funcs}|}`. |
| |
| #. Let :math:`\{ \mathsf{type}~{t_1^{k}}~\rightarrow~{t_2^{n}},\;\allowbreak \mathsf{module}~{\mathit{mm}},\;\allowbreak \mathsf{code}~{\mathit{func}} \}` be the destructuring of :math:`z{.}\mathsf{funcs}{}[a]`. |
| |
| #. Let :math:`(\mathsf{func}~x~{{\mathit{local}}_0^\ast}~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{func}}`. |
| |
| #. Let :math:`{t^\ast}` be the value type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{local}}_0` in :math:`{{\mathit{local}}_0^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{local}~t)` be the destructuring of :math:`{\mathit{local}}_0`. |
| |
| #. Append :math:`t` to :math:`{t^\ast}`. |
| |
| #. Assert: Due to validation, there are at least :math:`k` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{k}}` from the stack. |
| |
| #. Let :math:`f` be the frame :math:`\{ \mathsf{locals}~{{\mathit{val}}^{k}}~{{{\mathrm{default}}}_{t}^\ast},\;\allowbreak \mathsf{module}~{\mathit{mm}} \}`. |
| |
| #. Let :math:`{f'}` be the :math:`\mathsf{frame}` :math:`f` whose arity is :math:`n`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{f'}`. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`n` and whose continuation is the end of the block. |
| |
| #. Enter the block :math:`{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{ref{.}func}~x` |
| ............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`x < {|z{.}\mathsf{module}{.}\mathsf{funcs}|}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}func}~z{.}\mathsf{module}{.}\mathsf{funcs}{}[x])` to the stack. |
| |
| |
| :math:`\mathsf{local{.}get}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Push the value :math:`z{.}\mathsf{locals}{}[x]` to the stack. |
| |
| |
| :math:`\mathsf{global{.}get}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Push the value :math:`z{.}\mathsf{globals}{}[x]{.}\mathsf{value}` to the stack. |
| |
| |
| :math:`\mathsf{table{.}get}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i \geq {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. Push the value :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i]` to the stack. |
| |
| |
| :math:`\mathsf{table{.}size}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`n` be the length of :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` to the stack. |
| |
| |
| :math:`\mathsf{table{.}fill}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}set}~x)`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}fill}~x)`. |
| |
| |
| :math:`\mathsf{table{.}copy}~x~y` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{tables}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. If :math:`j \leq i`, then: |
| |
| 1) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}get}~y)`. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}set}~x)`. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + 1)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Else: |
| |
| 1) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + n - 1)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + n - 1)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}get}~y)`. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}set}~x)`. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}copy}~x~y)`. |
| |
| |
| :math:`\mathsf{table{.}init}~x~y` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`i < {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` to the stack. |
| |
| #. Push the value :math:`z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}{}[i]` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}set}~x)`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}init}~x~y)`. |
| |
| |
| :math:`{{\mathit{nt}}{.}\mathsf{load}}{{{\mathit{loadop}}^?}}~{\mathit{ao}}` |
| ............................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`{{\mathit{loadop}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8]`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`{\mathit{nt}}` is :math:`{\mathsf{i}}{n}`. |
| |
| #. Let :math:`{\mathit{loadop}}_0` be :math:`{{\mathit{loadop}}^?}`. |
| |
| #. Let :math:`{n}{\mathsf{\_}}{{\mathit{sx}}}` be the destructuring of :math:`{\mathit{loadop}}_0`. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{n, {|{\mathit{nt}}|}}^{{\mathit{sx}}}}}{(c)})` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~{{\mathit{vloadop}}^?}~{\mathit{ao}}` |
| ......................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`{{\mathit{vloadop}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|\mathsf{v{\scriptstyle 128}}|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{\mathsf{v{\scriptstyle 128}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|\mathsf{v{\scriptstyle 128}}|} / 8]`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{vloadop}}_0` be :math:`{{\mathit{vloadop}}^?}`. |
| |
| #. If :math:`{\mathit{vloadop}}_0` is some :math:`{\mathbb{N}}{\mathsf{x}}{\mathbb{N}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({M}{\mathsf{x}}{N}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vloadop}}_0`. |
| |
| #) If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + M \cdot N / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a) Trap. |
| |
| #) Let :math:`{j^{N}}` be the result for which :math:`{({{\mathrm{bytes}}}_{{\mathsf{i}}{M}}({j^{N}}) = z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} + k \cdot M / 8 : M / 8])^{k<N}}`. |
| |
| #) Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`M \cdot 2`. |
| |
| #) Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{N}}({{{{{\mathrm{extend}}}_{M, {|{\mathsf{i}}{n}|}}^{{\mathit{sx}}}}}{(j)}^{N}})`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. If :math:`{\mathit{vloadop}}_0` is some :math:`{\mathbb{N}}{\mathsf{\_}}{\mathsf{splat}}`, then: |
| |
| 1) Let :math:`({N}{\mathsf{\_}}{\mathsf{splat}})` be the destructuring of :math:`{\mathit{vloadop}}_0`. |
| |
| #) If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a) Trap. |
| |
| #) Let :math:`M` be :math:`128 / N`. |
| |
| #) Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`N`. |
| |
| #) Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #) Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({j^{M}})`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. If :math:`{\mathit{vloadop}}_0` is some :math:`{\mathbb{N}}{\mathsf{\_}}{\mathsf{zero}}`, then: |
| |
| 1) Let :math:`({N}{\mathsf{\_}}{\mathsf{zero}})` be the destructuring of :math:`{\mathit{vloadop}}_0`. |
| |
| #) If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a) Trap. |
| |
| #) Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #) Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{N, 128}^{\mathsf{u}}}}{(j)}`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{vload\_lane}~\mathsf{v{\scriptstyle 128}}~N~{\mathit{ao}}~j` |
| ........................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`M` be :math:`128 / N`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`N`. |
| |
| #. Let :math:`k` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(k)` :math:`=` :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}(c_1){}[{}[j] = k])`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{memory{.}size}` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`n \cdot 64 \cdot {\mathrm{Ki}}` be the length of :math:`z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` to the stack. |
| |
| |
| :math:`\mathsf{memory{.}fill}` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8})`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{memory{.}fill}`. |
| |
| |
| :math:`\mathsf{memory{.}copy}` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. If :math:`j \leq i`, then: |
| |
| 1) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{load}}{{8}{\mathsf{\_}}{\mathsf{u}}})`. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8})`. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + 1)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Else: |
| |
| 1) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + n - 1)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + n - 1)` to the stack. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{load}}{{8}{\mathsf{\_}}{\mathsf{u}}})`. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8})`. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{memory{.}copy}`. |
| |
| |
| :math:`\mathsf{memory{.}init}~x` |
| ................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{datas}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`i < {|z{.}\mathsf{datas}{}[x]{.}\mathsf{bytes}|}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~z{.}\mathsf{datas}{}[x]{.}\mathsf{bytes}{}[i])` to the stack. |
| |
| #. Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8})`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{memory{.}init}~x)`. |
| |
| |
| :math:`\mathsf{local{.}set}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Perform :math:`z{}[{.}\mathsf{locals}{}[x] = {\mathit{val}}]`. |
| |
| |
| :math:`\mathsf{global{.}set}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Perform :math:`z{}[{.}\mathsf{globals}{}[x]{.}\mathsf{value} = {\mathit{val}}]`. |
| |
| |
| :math:`\mathsf{table{.}set}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a reference is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i \geq {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. Perform :math:`z{}[{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i] = {\mathit{ref}}]`. |
| |
| |
| :math:`\mathsf{table{.}grow}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a reference is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. Either: |
| |
| a. Let :math:`{\mathit{ti}}` be the table instance :math:`{\mathrm{growtable}}(z{.}\mathsf{tables}{}[x], n, {\mathit{ref}})`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|})` to the stack. |
| |
| #. Perform :math:`z{}[{.}\mathsf{tables}{}[x] = {\mathit{ti}}]`. |
| |
| #. Or: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{{{{\mathrm{signed}}}_{32}^{{-1}}}}{({-1})})` to the stack. |
| |
| |
| :math:`\mathsf{elem{.}drop}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Perform :math:`z{}[{.}\mathsf{elems}{}[x]{.}\mathsf{refs} = \epsilon]`. |
| |
| |
| :math:`{{\mathit{nt}}{.}\mathsf{store}}{{{\mathit{sz}}^?}}~{\mathit{ao}}` |
| ......................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{nt}'}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{\mathit{nt}} = {\mathit{nt}'}`. |
| |
| #. If :math:`{{\mathit{sz}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}'}|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathit{nt}'}}(c)`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}'}|} / 8] = {b^\ast}]`. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`{\mathit{nt}'}` is :math:`{\mathsf{i}}{n}`. |
| |
| #. Let :math:`n` be :math:`{{\mathit{sz}}^?}`. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}({{\mathrm{wrap}}}_{{|{\mathit{nt}'}|}, n}(c))`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8] = {b^\ast}]`. |
| |
| |
| :math:`\mathsf{vstore}~\mathsf{v{\scriptstyle 128}}~{\mathit{ao}}` |
| .................................................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|\mathsf{v{\scriptstyle 128}}|} / 8 > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{\mathsf{v{\scriptstyle 128}}}(c)`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|\mathsf{v{\scriptstyle 128}}|} / 8] = {b^\ast}]`. |
| |
| |
| :math:`\mathsf{vstore\_lane}~\mathsf{v{\scriptstyle 128}}~N~{\mathit{ao}}~j` |
| ............................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N > {|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`M` be :math:`128 / N`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`N`. |
| |
| #. Assert: Due to validation, :math:`j < {|{{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}(c)|}`. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}({{\mathrm{lanes}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}(c){}[j])`. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8] = {b^\ast}]`. |
| |
| |
| :math:`\mathsf{memory{.}grow}` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Either: |
| |
| a. Let :math:`{\mathit{mi}}` be the memory instance :math:`{\mathrm{growmemory}}(z{.}\mathsf{mems}{}[0], n)`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{|z{.}\mathsf{mems}{}[0]{.}\mathsf{bytes}|} / (64 \, {\mathrm{Ki}}))` to the stack. |
| |
| #. Perform :math:`z{}[{.}\mathsf{mems}{}[0] = {\mathit{mi}}]`. |
| |
| #. Or: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{{{{\mathrm{signed}}}_{32}^{{-1}}}}{({-1})})` to the stack. |
| |
| |
| :math:`\mathsf{data{.}drop}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Perform :math:`z{}[{.}\mathsf{datas}{}[x]{.}\mathsf{bytes} = \epsilon]`. |
| |
| |
| :math:`{\mathrm{Ki}}` |
| ..................... |
| |
| |
| 1. Return :math:`1024`. |
| |
| |
| :math:`{\mathrm{min}}(i, j)` |
| ............................ |
| |
| |
| 1. If :math:`i \leq j`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Return :math:`j`. |
| |
| |
| :math:`{\mathrm{sum}}({{n''}^\ast})` |
| .................................... |
| |
| |
| 1. If :math:`{{n''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`0`. |
| |
| #. Let :math:`n~{{n'}^\ast}` be :math:`{{n''}^\ast}`. |
| |
| #. Return :math:`n + {\mathrm{sum}}({{n'}^\ast})`. |
| |
| |
| :math:`{X^\ast}` |
| ................ |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{|{X^\ast}|} = 1`, then: |
| |
| a. Let :math:`w` be :math:`{X^\ast}`. |
| |
| #. Return :math:`w`. |
| |
| #. Fail. |
| |
| |
| :math:`{X^?}` |
| ............. |
| |
| |
| 1. If :math:`{X^?}` is not defined, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`w` be :math:`{X^?}`. |
| |
| #. Return :math:`w`. |
| |
| |
| :math:`{\mathrm{concat}}({X^\ast})` |
| ................................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{w^\ast}~{{{w'}^\ast}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{w^\ast}~{\mathrm{concat}}({{{w'}^\ast}^\ast})`. |
| |
| |
| :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 2}}}}_{X}(w_1, {X^\ast})` |
| ............................................................................. |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{{w'}^\ast}~{{w^\ast}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`w_1~{{w'}^\ast}~{{\mathrm{setproduct{\kern-0.1em\scriptstyle 2}}}}_{X}(w_1, {{w^\ast}^\ast})`. |
| |
| |
| :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 1}}}}_{X}({X^\ast}, {{w^\ast}^\ast})` |
| ......................................................................................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`w_1~{{w'}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 2}}}}_{X}(w_1, {{w^\ast}^\ast})~{{\mathrm{setproduct{\kern-0.1em\scriptstyle 1}}}}_{X}({{w'}^\ast}, {{w^\ast}^\ast})`. |
| |
| |
| :math:`{\Large\times}~{X^\ast}` |
| ............................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{w_1^\ast}~{{w^\ast}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 1}}}}_{X}({w_1^\ast}, {\Large\times}~{{w^\ast}^\ast})`. |
| |
| |
| :math:`{\mathrm{signif}}(N)` |
| ............................ |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`23`. |
| |
| #. If :math:`N = 64`, then: |
| |
| a. Return :math:`52`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{expon}}(N)` |
| ........................... |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`8`. |
| |
| #. If :math:`N = 64`, then: |
| |
| a. Return :math:`11`. |
| |
| #. Fail. |
| |
| |
| :math:`M` |
| ......... |
| |
| |
| 1. Return :math:`{\mathrm{signif}}(N)`. |
| |
| |
| :math:`E` |
| ......... |
| |
| |
| 1. Return :math:`{\mathrm{expon}}(N)`. |
| |
| |
| :math:`{+0}` |
| ............ |
| |
| |
| 1. Return :math:`({+((0 + 0 \cdot {2^{{-M}}}) \cdot {2^{e}})})`. |
| |
| |
| :math:`{+1}` |
| ............ |
| |
| |
| 1. Return :math:`({+((1 + 1 \cdot {2^{{-M}}}) \cdot {2^{0}})})`. |
| |
| |
| :math:`{{\mathrm{canon}}}_{N}` |
| .............................. |
| |
| |
| 1. Return :math:`{2^{{\mathrm{signif}}(N) - 1}}`. |
| |
| |
| :math:`{\mathrm{lanetype}}({{\mathsf{i}}{n}}{\mathsf{x}}{N})` |
| ............................................................. |
| |
| |
| 1. Return :math:`{\mathsf{i}}{n}`. |
| |
| |
| :math:`{|{\mathit{valtype}}|}` |
| .............................. |
| |
| |
| 1. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`32`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 64}}`, then: |
| |
| a. Return :math:`64`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`32`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 64}}`, then: |
| |
| a. Return :math:`64`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{v{\scriptstyle 128}}`, then: |
| |
| a. Return :math:`128`. |
| |
| #. Fail. |
| |
| |
| :math:`{|{\mathit{packtype}}|}` |
| ............................... |
| |
| |
| 1. If :math:`{\mathit{packtype}} = \mathsf{i{\scriptstyle 8}}`, then: |
| |
| a. Return :math:`8`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{packtype}} = \mathsf{i{\scriptstyle 16}}`. |
| |
| #. Return :math:`16`. |
| |
| |
| :math:`{|{\mathit{lanetype}}|}` |
| ............................... |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`{|{\mathit{lanetype}}|}`. |
| |
| |
| :math:`{|{\mathsf{i}}{n}|}` |
| ........................... |
| |
| |
| 1. Return :math:`{|{\mathsf{i}}{n}|}`. |
| |
| |
| :math:`{|{\mathsf{i}}{n}|}` |
| ........................... |
| |
| |
| 1. Return :math:`{|{\mathsf{i}}{n}|}`. |
| |
| |
| :math:`{|{\mathsf{f}}{n}|}` |
| ........................... |
| |
| |
| 1. Return :math:`{|{\mathsf{f}}{n}|}`. |
| |
| |
| :math:`N` |
| ......... |
| |
| |
| 1. Return :math:`{|{\mathit{nt}}|}`. |
| |
| |
| :math:`N_1` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{nt}}|}`. |
| |
| |
| :math:`N_2` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{nt}}|}`. |
| |
| |
| :math:`N` |
| ......... |
| |
| |
| 1. Return :math:`{|{\mathit{lt}}|}`. |
| |
| |
| :math:`N_1` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{lt}}|}`. |
| |
| |
| :math:`N_2` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{lt}}|}`. |
| |
| |
| :math:`{\mathrm{inv}}_{\mathit{isize}}(n)` |
| .......................................... |
| |
| |
| 1. If :math:`n = 32`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| #. If :math:`n = 64`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 64}}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{inv}}_{\mathit{jsize}}(n)` |
| .......................................... |
| |
| |
| 1. If :math:`n = 8`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 8}}`. |
| |
| #. If :math:`n = 16`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 16}}`. |
| |
| #. If :math:`n = 32`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| #. If :math:`n = 64`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 64}}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{inv}}_{\mathit{fsize}}(n)` |
| .......................................... |
| |
| |
| 1. If :math:`n = 32`, then: |
| |
| a. Return :math:`\mathsf{f{\scriptstyle 32}}`. |
| |
| #. If :math:`n = 64`, then: |
| |
| a. Return :math:`\mathsf{f{\scriptstyle 64}}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{zero}}({\mathit{numtype}})` |
| ........................................... |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. Return :math:`0`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. Return :math:`{+0}`. |
| |
| |
| :math:`{\mathrm{dim}}({{\mathsf{i}}{n}}{\mathsf{x}}{N})` |
| ........................................................ |
| |
| |
| 1. Return :math:`N`. |
| |
| |
| :math:`{|{{\mathsf{i}}{n}}{\mathsf{x}}{N}|}` |
| ............................................ |
| |
| |
| 1. Return :math:`{|{\mathsf{i}}{n}|} \cdot N`. |
| |
| |
| :math:`{\mathrm{concat}}({{\mathit{byte}}^\ast})` |
| ................................................. |
| |
| |
| 1. If :math:`{{\mathit{byte}}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{b^\ast}~{{{b'}^\ast}^\ast}` be :math:`{{\mathit{byte}}^\ast}`. |
| |
| #. Return :math:`{b^\ast}~{\mathrm{concat}}({{{b'}^\ast}^\ast})`. |
| |
| |
| :math:`{\mathrm{unpack}}({\mathit{lanetype}})` |
| .............................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`{\mathit{lanetype}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| :math:`{\mathrm{unpack}}({{\mathsf{i}}{n}}{\mathsf{x}}{N})` |
| ........................................................... |
| |
| |
| 1. Return :math:`{\mathrm{unpack}}({\mathsf{i}}{n})`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externtype}'}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{func}~{\mathit{functype}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{ft}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{ft}}~{\mathrm{funcs}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externtype}'}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{global}~{\mathit{globaltype}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{gt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{gt}}~{\mathrm{globals}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externtype}'}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{table}~{\mathit{tabletype}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{tt}}~{\mathrm{tables}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externtype}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{mem}~{\mathit{memtype}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{mt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{mt}}~{\mathrm{mems}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{dataidx}}({\mathit{instr}})` |
| ............................................ |
| |
| |
| 1. If :math:`{\mathit{instr}}` is some :math:`\mathsf{memory{.}init}~{\mathit{dataidx}}`, then: |
| |
| a. Let :math:`(\mathsf{memory{.}init}~x)` be the destructuring of :math:`{\mathit{instr}}`. |
| |
| #. Return :math:`x`. |
| |
| #. If :math:`{\mathit{instr}}` is some :math:`\mathsf{data{.}drop}~{\mathit{dataidx}}`, then: |
| |
| a. Let :math:`(\mathsf{data{.}drop}~x)` be the destructuring of :math:`{\mathit{instr}}`. |
| |
| #. Return :math:`x`. |
| |
| #. Return :math:`\epsilon`. |
| |
| |
| :math:`{\mathrm{dataidx}}({{\mathit{instr}''}^\ast})` |
| ..................................................... |
| |
| |
| 1. If :math:`{{\mathit{instr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{instr}}~{{\mathit{instr}'}^\ast}` be :math:`{{\mathit{instr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{dataidx}}({\mathit{instr}})~{\mathrm{dataidx}}({{\mathit{instr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{dataidx}}({{\mathit{in}}^\ast})` |
| ................................................ |
| |
| |
| 1. Return :math:`{\mathrm{dataidx}}({{\mathit{in}}^\ast})`. |
| |
| |
| :math:`{\mathrm{dataidx}}(\mathsf{func}~x~{{\mathit{loc}}^\ast}~e)` |
| ................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{dataidx}}(e)`. |
| |
| |
| :math:`{\mathrm{dataidx}}({{\mathit{func}''}^\ast})` |
| .................................................... |
| |
| |
| 1. If :math:`{{\mathit{func}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{func}}~{{\mathit{func}'}^\ast}` be :math:`{{\mathit{func}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{dataidx}}({\mathit{func}})~{\mathrm{dataidx}}({{\mathit{func}'}^\ast})`. |
| |
| |
| |
| |
| |
| |
| 1. Return :math:`\{ \mathsf{align}~0,\;\allowbreak \mathsf{offset}~0 \}`. |
| |
| |
| :math:`\mathbb{B}(b)` |
| ..................... |
| |
| |
| 1. If :math:`b` is false, then: |
| |
| a. Return :math:`0`. |
| |
| #. Assert: Due to validation, :math:`b` is true. |
| |
| #. Return :math:`1`. |
| |
| |
| :math:`{{\mathrm{signed}}}_{N}(i)` |
| .................................. |
| |
| |
| 1. If :math:`i < {2^{N - 1}}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{2^{N - 1}} \leq i`. |
| |
| #. Assert: Due to validation, :math:`i < {2^{N}}`. |
| |
| #. Return :math:`i - {2^{N}}`. |
| |
| |
| :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{(i)}` |
| ............................................... |
| |
| |
| 1. If :math:`0 \leq i` and :math:`i < {2^{N - 1}}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{-{2^{N - 1}}} \leq i`. |
| |
| #. Assert: Due to validation, :math:`i < 0`. |
| |
| #. Return :math:`i + {2^{N}}`. |
| |
| |
| :math:`{{\mathrm{sat\_u}}}_{N}(i)` |
| .................................. |
| |
| |
| 1. If :math:`i < 0`, then: |
| |
| a. Return :math:`0`. |
| |
| #. If :math:`i > {2^{N}} - 1`, then: |
| |
| a. Return :math:`{2^{N}} - 1`. |
| |
| #. Return :math:`i`. |
| |
| |
| :math:`{{\mathrm{sat\_s}}}_{N}(i)` |
| .................................. |
| |
| |
| 1. If :math:`i < {-{2^{N - 1}}}`, then: |
| |
| a. Return :math:`{-{2^{N - 1}}}`. |
| |
| #. If :math:`i > {2^{N - 1}} - 1`, then: |
| |
| a. Return :math:`{2^{N - 1}} - 1`. |
| |
| #. Return :math:`i`. |
| |
| |
| :math:`{{\mathit{unop}}}{{}_{{\mathit{numtype}}}}{({\mathit{iN}})}` |
| ................................................................... |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{unop}} = \mathsf{clz}`, then: |
| |
| 1) Return :math:`{{\mathrm{iclz}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{ctz}`, then: |
| |
| 1) Return :math:`{{\mathrm{ictz}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{popcnt}`, then: |
| |
| 1) Return :math:`{{\mathrm{ipopcnt}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}}` is some :math:`\mathsf{extend}~n`, then: |
| |
| 1) Let :math:`(\mathsf{extend}~N)` be the destructuring of :math:`{\mathit{unop}}`. |
| |
| #) Return :math:`{{{{\mathrm{extend}}}_{N, N}^{\mathsf{s}}}}{({{\mathrm{wrap}}}_{N, N}({\mathit{iN}}))}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{abs}`, then: |
| |
| a. Return :math:`{{\mathrm{fabs}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{neg}`, then: |
| |
| a. Return :math:`{{\mathrm{fneg}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{sqrt}`, then: |
| |
| a. Return :math:`{{\mathrm{fsqrt}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{ceil}`, then: |
| |
| a. Return :math:`{{\mathrm{fceil}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{floor}`, then: |
| |
| a. Return :math:`{{\mathrm{ffloor}}}_{N}({\mathit{iN}})`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{trunc}`, then: |
| |
| a. Return :math:`{{\mathrm{ftrunc}}}_{N}({\mathit{iN}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{unop}} = \mathsf{nearest}`. |
| |
| #. Return :math:`{{\mathrm{fnearest}}}_{N}({\mathit{iN}})`. |
| |
| |
| :math:`{{\mathrm{iadd}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`(i_1 + i_2) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{{{\mathrm{idiv}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................. |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_2 = 0`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Return :math:`{\mathrm{truncz}}(i_1 / i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`i_2 = 0`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i_1) / {{\mathrm{signed}}}_{N}(i_2) = {2^{N - 1}}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({\mathrm{truncz}}({{\mathrm{signed}}}_{N}(i_1) / {{\mathrm{signed}}}_{N}(i_2)))}`. |
| |
| |
| :math:`{{\mathrm{imul}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`i_1 \cdot i_2 \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{{{\mathrm{irem}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................. |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_2 = 0`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Return :math:`i_1 - i_2 \cdot {\mathrm{truncz}}(i_1 / i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`i_2 = 0`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`j_1` be :math:`{{\mathrm{signed}}}_{N}(i_1)`. |
| |
| #. Let :math:`j_2` be :math:`{{\mathrm{signed}}}_{N}(i_2)`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{(j_1 - j_2 \cdot {\mathrm{truncz}}(j_1 / j_2))}`. |
| |
| |
| :math:`{{\mathrm{isub}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`({2^{N}} + i_1 - i_2) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{\mathit{binop}}}{{}_{{\mathit{numtype}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}` |
| ....................................................................................... |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{binop}} = \mathsf{add}`, then: |
| |
| 1) Return :math:`{{\mathrm{iadd}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{sub}`, then: |
| |
| 1) Return :math:`{{\mathrm{isub}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{mul}`, then: |
| |
| 1) Return :math:`{{\mathrm{imul}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{div}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{div}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{{{\mathrm{idiv}}}_{N}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{rem}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{rem}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{{{\mathrm{irem}}}_{N}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{and}`, then: |
| |
| 1) Return :math:`{{\mathrm{iand}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{or}`, then: |
| |
| 1) Return :math:`{{\mathrm{ior}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{xor}`, then: |
| |
| 1) Return :math:`{{\mathrm{ixor}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{shl}`, then: |
| |
| 1) Return :math:`{{\mathrm{ishl}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{shr}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{shr}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ishr}}}_{N}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{rotl}`, then: |
| |
| 1) Return :math:`{{\mathrm{irotl}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{rotr}`, then: |
| |
| 1) Return :math:`{{\mathrm{irotr}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{add}`, then: |
| |
| a. Return :math:`{{\mathrm{fadd}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{sub}`, then: |
| |
| a. Return :math:`{{\mathrm{fsub}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{mul}`, then: |
| |
| a. Return :math:`{{\mathrm{fmul}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{div}`, then: |
| |
| a. Return :math:`{{\mathrm{fdiv}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{min}`, then: |
| |
| a. Return :math:`{{\mathrm{fmin}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{max}`, then: |
| |
| a. Return :math:`{{\mathrm{fmax}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{binop}} = \mathsf{copysign}`. |
| |
| #. Return :math:`{{\mathrm{fcopysign}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| |
| :math:`{{\mathrm{ieqz}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 = 0)`. |
| |
| |
| :math:`{\mathsf{eqz}}{{}_{{\mathsf{i}}{n}}}{({\mathit{iN}})}` |
| ............................................................. |
| |
| |
| 1. Return :math:`{{\mathrm{ieqz}}}_{N}({\mathit{iN}})`. |
| |
| |
| :math:`{{\mathrm{ieq}}}_{N}(i_1, i_2)` |
| ...................................... |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 = i_2)`. |
| |
| |
| :math:`{{{{\mathrm{ige}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 \geq i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) \geq {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{{{\mathrm{igt}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 > i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) > {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{{{\mathrm{ile}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 \leq i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) \leq {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{{{\mathrm{ilt}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 < i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) < {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{\mathrm{ine}}}_{N}(i_1, i_2)` |
| ...................................... |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 \neq i_2)`. |
| |
| |
| :math:`{{\mathit{relop}}}{{}_{{\mathit{numtype}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}` |
| ....................................................................................... |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{relop}} = \mathsf{eq}`, then: |
| |
| 1) Return :math:`{{\mathrm{ieq}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{ne}`, then: |
| |
| 1) Return :math:`{{\mathrm{ine}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{lt}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{lt}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ilt}}}_{N}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{gt}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{gt}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{igt}}}_{N}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{le}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{le}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ile}}}_{N}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{ge}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{ge}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{{{\mathrm{ige}}}_{N}^{{\mathit{sx}}}}}{({\mathit{iN}}_1, {\mathit{iN}}_2)}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{eq}`, then: |
| |
| a. Return :math:`{{\mathrm{feq}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{ne}`, then: |
| |
| a. Return :math:`{{\mathrm{fne}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{lt}`, then: |
| |
| a. Return :math:`{{\mathrm{flt}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{gt}`, then: |
| |
| a. Return :math:`{{\mathrm{fgt}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{le}`, then: |
| |
| a. Return :math:`{{\mathrm{fle}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{relop}} = \mathsf{ge}`. |
| |
| #. Return :math:`{{\mathrm{fge}}}_{N}({\mathit{iN}}_1, {\mathit{iN}}_2)`. |
| |
| |
| :math:`{{\mathit{cvtop}}}{{}_{{\mathit{numtype}}, {\mathit{numtype}'}}}{({\mathit{iN}}_1)}` |
| ........................................................................................... |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{n}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{cvtop}}` is some :math:`\mathsf{extend}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{extend}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #) Return :math:`{{{{\mathrm{extend}}}_{N_1, N_2}^{{\mathit{sx}}}}}{({\mathit{iN}}_1)}`. |
| |
| #. If :math:`{\mathit{cvtop}} = \mathsf{wrap}`, then: |
| |
| 1) Return :math:`{{\mathrm{wrap}}}_{N_1, N_2}({\mathit{iN}}_1)`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{n}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{cvtop}}` is some :math:`\mathsf{trunc}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{trunc}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #) Return :math:`{{{{\mathrm{trunc}}}_{N_1, N_2}^{{\mathit{sx}}}}}{({\mathit{iN}}_1)}`. |
| |
| #. If :math:`{\mathit{cvtop}}` is some :math:`\mathsf{trunc\_sat}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{trunc\_sat}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #) Return :math:`{{{{\mathrm{trunc\_sat}}}_{N_1, N_2}^{{\mathit{sx}}}}}{({\mathit{iN}}_1)}`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{n}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{f}}{n}` and :math:`{\mathit{cvtop}}` is some :math:`\mathsf{convert}~{\mathit{sx}}`, then: |
| |
| a. Let :math:`(\mathsf{convert}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #. Return :math:`{{{{\mathrm{convert}}}_{N_1, N_2}^{{\mathit{sx}}}}}{({\mathit{iN}}_1)}`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{n}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{f}}{n}`, then: |
| |
| a. If :math:`{\mathit{cvtop}} = \mathsf{promote}`, then: |
| |
| 1) Return :math:`{{\mathrm{promote}}}_{N_1, N_2}({\mathit{iN}}_1)`. |
| |
| #. If :math:`{\mathit{cvtop}} = \mathsf{demote}`, then: |
| |
| 1) Return :math:`{{\mathrm{demote}}}_{N_1, N_2}({\mathit{iN}}_1)`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{n}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{f}}{n}` and :math:`{\mathit{cvtop}} = \mathsf{reinterpret}` and :math:`{|{\mathit{numtype}}|} = {|{\mathit{numtype}'}|}`, then: |
| |
| a. Return :math:`{{\mathrm{reinterpret}}}_{{\mathit{numtype}}, {\mathit{numtype}'}}({\mathit{iN}}_1)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}'}` is :math:`{\mathsf{i}}{n}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{cvtop}} = \mathsf{reinterpret}`. |
| |
| #. Assert: Due to validation, :math:`{|{\mathit{numtype}}|} = {|{\mathit{numtype}'}|}`. |
| |
| #. Return :math:`{{\mathrm{reinterpret}}}_{{\mathit{numtype}}, {\mathit{numtype}'}}({\mathit{iN}}_1)`. |
| |
| |
| :math:`{{\mathrm{inez}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 \neq 0)`. |
| |
| |
| :math:`{{\mathrm{ineg}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`({2^{N}} - i_1) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{\mathrm{iabs}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. If :math:`{{\mathrm{signed}}}_{N}(i_1) \geq 0`, then: |
| |
| a. Return :math:`i_1`. |
| |
| #. Return :math:`{{\mathrm{ineg}}}_{N}(i_1)`. |
| |
| |
| :math:`{{\mathrm{imin}}}_{N}({\mathit{sx}}, i_1, i_2)` |
| ...................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_1 \leq i_2`, then: |
| |
| 1) Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i_1) \leq {{\mathrm{signed}}}_{N}(i_2)`, then: |
| |
| a. Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| |
| :math:`{{\mathrm{imax}}}_{N}({\mathit{sx}}, i_1, i_2)` |
| ...................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_1 \geq i_2`, then: |
| |
| 1) Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i_1) \geq {{\mathrm{signed}}}_{N}(i_2)`, then: |
| |
| a. Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| |
| :math:`{{{{\mathrm{iadd\_sat}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| .................................................................. |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`{{\mathrm{sat\_u}}}_{N}(i_1 + i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({{\mathrm{sat\_s}}}_{N}({{\mathrm{signed}}}_{N}(i_1) + {{\mathrm{signed}}}_{N}(i_2)))}`. |
| |
| |
| :math:`{{{{\mathrm{isub\_sat}}}_{N}^{{\mathit{sx}}}}}{(i_1, i_2)}` |
| .................................................................. |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`{{\mathrm{sat\_u}}}_{N}(i_1 - i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({{\mathrm{sat\_s}}}_{N}({{\mathrm{signed}}}_{N}(i_1) - {{\mathrm{signed}}}_{N}(i_2)))}`. |
| |
| |
| :math:`{{\mathrm{pack}}}_{{\mathit{lanetype}}}(c)` |
| .................................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`{{\mathrm{wrap}}}_{{|{\mathrm{unpack}}({\mathit{lanetype}})|}, {|{\mathit{lanetype}}|}}(c)`. |
| |
| |
| :math:`{{\mathrm{unpack}}}_{{\mathit{lanetype}}}(c)` |
| .................................................... |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`{{{{\mathrm{extend}}}_{{|{\mathit{lanetype}}|}, {|{\mathrm{unpack}}({\mathit{lanetype}})|}}^{\mathsf{u}}}}{(c)}`. |
| |
| |
| :math:`{\mathrm{zeroop}}({\mathit{vcvtop}})` |
| ............................................ |
| |
| |
| 1. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{extend}~{\mathit{half}}~{\mathit{sx}}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{convert}~{{\mathit{half}}^?}~{\mathit{sx}}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{trunc\_sat}~{\mathit{sx}}~{{\mathit{zero}}^?}`, then: |
| |
| a. Let :math:`(\mathsf{trunc\_sat}~{\mathit{sx}}~{{\mathit{zero}}^?})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #. Return :math:`{{\mathit{zero}}^?}`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{demote}~{\mathit{zero}}`, then: |
| |
| a. Let :math:`(\mathsf{demote}~{\mathit{zero}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #. Return :math:`{\mathit{zero}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vcvtop}} = `. |
| |
| #. Return :math:`\epsilon`. |
| |
| |
| :math:`{\mathrm{halfop}}({\mathit{vcvtop}})` |
| ............................................ |
| |
| |
| 1. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{extend}~{\mathit{half}}~{\mathit{sx}}`, then: |
| |
| a. Let :math:`(\mathsf{extend}~{\mathit{half}}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #. Return :math:`{\mathit{half}}`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{convert}~{{\mathit{half}}^?}~{\mathit{sx}}`, then: |
| |
| a. Let :math:`(\mathsf{convert}~{{\mathit{half}}^?}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #. Return :math:`{{\mathit{half}}^?}`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{trunc\_sat}~{\mathit{sx}}~{{\mathit{zero}}^?}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{demote}~{\mathit{zero}}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vcvtop}} = `. |
| |
| #. Return :math:`\mathsf{low}`. |
| |
| |
| :math:`{\mathrm{half}}({\mathit{half}}, i, j)` |
| .............................................. |
| |
| |
| 1. If :math:`{\mathit{half}} = \mathsf{low}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{half}} = \mathsf{high}`. |
| |
| #. Return :math:`j`. |
| |
| |
| :math:`{\mathsf{not}}{{}_{\mathsf{v{\scriptstyle 128}}}({\mathit{v{\kern-0.1em\scriptstyle 128}}})}` |
| .................................................................................................... |
| |
| |
| 1. Return :math:`{{\mathrm{inot}}}_{{|\mathsf{v{\scriptstyle 128}}|}}({\mathit{v{\kern-0.1em\scriptstyle 128}}})`. |
| |
| |
| :math:`{{\mathit{vvbinop}}}{{}_{\mathsf{v{\scriptstyle 128}}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)}` |
| ......................................................................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{vvbinop}} = \mathsf{and}`, then: |
| |
| a. Return :math:`{{\mathrm{iand}}}_{{|\mathsf{v{\scriptstyle 128}}|}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. If :math:`{\mathit{vvbinop}} = \mathsf{andnot}`, then: |
| |
| a. Return :math:`{{\mathrm{iandnot}}}_{{|\mathsf{v{\scriptstyle 128}}|}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. If :math:`{\mathit{vvbinop}} = \mathsf{or}`, then: |
| |
| a. Return :math:`{{\mathrm{ior}}}_{{|\mathsf{v{\scriptstyle 128}}|}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vvbinop}} = \mathsf{xor}`. |
| |
| #. Return :math:`{{\mathrm{ixor}}}_{{|\mathsf{v{\scriptstyle 128}}|}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| |
| :math:`{\mathsf{bitselect}}{{}_{\mathsf{v{\scriptstyle 128}}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_3)}` |
| ...................................................................................................................................................................................................... |
| |
| |
| 1. Return :math:`{{\mathrm{ibitselect}}}_{{|\mathsf{v{\scriptstyle 128}}|}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_3)`. |
| |
| |
| :math:`{{\mathit{vunop}}}{{}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}}{({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)}` |
| .................................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{vunop}} = \mathsf{abs}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{iabs}}}_{N}({\mathit{lane}}_1)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{neg}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{ineg}}}_{N}({\mathit{lane}}_1)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{popcnt}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{ipopcnt}}}_{N}({\mathit{lane}}_1)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{abs}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fabs}}}_{N}({\mathit{lane}}_1)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{neg}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fneg}}}_{N}({\mathit{lane}}_1)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{sqrt}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fsqrt}}}_{N}({\mathit{lane}}_1)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{ceil}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fceil}}}_{N}({\mathit{lane}}_1)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{floor}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{ffloor}}}_{N}({\mathit{lane}}_1)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{trunc}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{ftrunc}}}_{N}({\mathit{lane}}_1)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vunop}} = \mathsf{nearest}`. |
| |
| #. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fnearest}}}_{N}({\mathit{lane}}_1)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #. Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| |
| :math:`{{\mathit{vbinop}}}{{}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}}{({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)}` |
| .................................................................................................................................................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{vbinop}} = \mathsf{add}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{iadd}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{sub}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{isub}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{min}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{min}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{imin}}}_{N}({\mathit{sx}}, {\mathit{lane}}_1, {\mathit{lane}}_2)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{max}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{max}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{imax}}}_{N}({\mathit{sx}}, {\mathit{lane}}_1, {\mathit{lane}}_2)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{add\_sat}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{add\_sat}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{{{\mathrm{iadd\_sat}}}_{N}^{{\mathit{sx}}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)}^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{sub\_sat}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{sub\_sat}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{{{\mathrm{isub\_sat}}}_{N}^{{\mathit{sx}}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)}^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{mul}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{\mathrm{imul}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}} = `, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{{{\mathrm{iavgr}}}_{N}^{\mathsf{u}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)}^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vbinop}} = `, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{{{{\mathrm{iq{\kern-0.1em\scriptstyle 15\kern-0.1em}mulr\_sat}}}_{N}^{\mathsf{s}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)}^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{add}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fadd}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{sub}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fsub}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{mul}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fmul}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{div}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fdiv}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{min}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fmin}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{max}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fmax}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{pmin}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fpmin}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #) Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vbinop}} = \mathsf{pmax}`. |
| |
| #. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{{{\mathit{lane}}^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{fpmax}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2)^\ast}`. |
| |
| #. Let :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{lane}}^\ast}` in :math:`{{{\mathit{lane}}^\ast}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}^\ast})`. |
| |
| #. Append :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` to :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{v{\kern-0.1em\scriptstyle 128}}}^\ast}`. |
| |
| |
| :math:`{{\mathit{vrelop}}}{{}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}}{({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1, {\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)}` |
| .................................................................................................................................................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{vrelop}} = \mathsf{eq}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #) For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| a) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{ieq}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{ne}`, then: |
| |
| 1) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #) For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| a) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{ine}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`\mathsf{lt}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{lt}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #) For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| a) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{{{\mathrm{ilt}}}_{N}^{{\mathit{sx}}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)})}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`\mathsf{gt}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{gt}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #) For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| a) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{{{\mathrm{igt}}}_{N}^{{\mathit{sx}}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)})}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`\mathsf{le}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{le}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #) For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| a) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{{{\mathrm{ile}}}_{N}^{{\mathit{sx}}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)})}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`\mathsf{ge}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{ge}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #) Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #) Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #) For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| a) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{{{\mathrm{ige}}}_{N}^{{\mathit{sx}}}}}{({\mathit{lane}}_1, {\mathit{lane}}_2)})}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #) Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #) Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{eq}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{feq}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #. Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{ne}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{fne}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #. Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{lt}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{flt}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #. Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{gt}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{fgt}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #. Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{le}`, then: |
| |
| a. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{fle}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #) Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #. Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vrelop}} = \mathsf{ge}`. |
| |
| #. Let :math:`{{\mathit{lane}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_1)`. |
| |
| #. Let :math:`{{\mathit{lane}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathit{v{\kern-0.1em\scriptstyle 128}}}_2)`. |
| |
| #. Let :math:`{\mathsf{i}}{n}` be the result for which :math:`{|{\mathsf{i}}{n}|}` :math:`=` :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Let :math:`{{\mathit{lane}}_3^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{lane}}_1` in :math:`{{\mathit{lane}}_1^\ast}` and :math:`{\mathit{lane}}_2` in :math:`{{\mathit{lane}}_2^\ast}`, do: |
| |
| a. Let :math:`{\mathit{lane}}_3` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{fge}}}_{N}({\mathit{lane}}_1, {\mathit{lane}}_2))}`. |
| |
| #. Append :math:`{\mathit{lane}}_3` to :math:`{{\mathit{lane}}_3^\ast}`. |
| |
| #. Let :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{\mathsf{i}}{n}}{\mathsf{x}}{M}}({{\mathit{lane}}_3^\ast})`. |
| |
| #. Return :math:`{\mathit{v{\kern-0.1em\scriptstyle 128}}}`. |
| |
| |
| :math:`{{\mathrm{vcvtop}}}_{{{\mathit{lanetype}'}}{\mathsf{x}}{M_1}, {{\mathit{lanetype}}}{\mathsf{x}}{M_2}}({\mathit{vcvtop}}, {\mathit{iN}}_1)` |
| ................................................................................................................................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{i}}{n}`, then: |
| |
| a. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{n}` and :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{extend}~{\mathit{half}}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{extend}~{\mathit{half}}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Let :math:`{\mathit{iN}}_2` be :math:`{{{{\mathrm{extend}}}_{N_1, N_2}^{{\mathit{sx}}}}}{({\mathit{iN}}_1)}`. |
| |
| #) Return :math:`{\mathit{iN}}_2`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{n}` and :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{convert}~{{\mathit{half}}^?}~{\mathit{sx}}`, then: |
| |
| 1) Let :math:`(\mathsf{convert}~{{\mathit{half}}^?}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Let :math:`{\mathit{fN}}_2` be :math:`{{{{\mathrm{convert}}}_{N_1, N_2}^{{\mathit{sx}}}}}{({\mathit{iN}}_1)}`. |
| |
| #) Return :math:`{\mathit{fN}}_2`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{n}` and :math:`{\mathit{vcvtop}}` is some :math:`\mathsf{trunc\_sat}~{\mathit{sx}}~{{\mathit{zero}}^?}`, then: |
| |
| a. Let :math:`(\mathsf{trunc\_sat}~{\mathit{sx}}~{{\mathit{zero}}^?})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #. Let :math:`{{\mathit{iN}}_2^?}` be :math:`{{{{\mathrm{trunc\_sat}}}_{N_1, N_2}^{{\mathit{sx}}}}}{({\mathit{iN}}_1)}`. |
| |
| #. Return :math:`{{\mathit{iN}}_2^?}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{n}`. |
| |
| #. If :math:`{\mathit{vcvtop}} = (\mathsf{demote}~\mathsf{zero})`, then: |
| |
| a. Let :math:`{{\mathit{fN}}_2^\ast}` be :math:`{{\mathrm{demote}}}_{N_1, N_2}({\mathit{iN}}_1)`. |
| |
| #. Return :math:`{{\mathit{fN}}_2^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vcvtop}} = `. |
| |
| #. Let :math:`{{\mathit{fN}}_2^\ast}` be :math:`{{\mathrm{promote}}}_{N_1, N_2}({\mathit{iN}}_1)`. |
| |
| #. Return :math:`{{\mathit{fN}}_2^\ast}`. |
| |
| |
| :math:`{{\mathrm{vextunop}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M_2}}(\mathsf{extadd\_pairwise}~{\mathit{sx}}, c_1)` |
| ............................................................................................................................................................ |
| |
| |
| 1. Let :math:`{{\mathit{ci}}^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M_2}}(c_1)`. |
| |
| #. Let :math:`{{\mathit{cj}}_1~{\mathit{cj}}_2^\ast}` be the result for which the :ref:`concatenation <notation-concat>` of :math:`{{\mathit{cj}}_1~{\mathit{cj}}_2^\ast}` is :math:`{{{{{\mathrm{extend}}}_{N_2, N_1}^{{\mathit{sx}}}}}{({\mathit{ci}})}^\ast}`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{M_1}}({{{\mathrm{iadd}}}_{N_1}({\mathit{cj}}_1, {\mathit{cj}}_2)^\ast})`. |
| |
| #. Return :math:`c`. |
| |
| |
| :math:`{{\mathrm{vextbinop}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M_2}}({\mathit{vextbinop}}, c_1, c_2)` |
| ............................................................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{vextbinop}}` is some :math:`{\mathsf{extmul}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| a. Let :math:`({\mathsf{extmul}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vextbinop}}`. |
| |
| #. Let :math:`{{\mathit{ci}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M_2}}(c_1){}[{\mathrm{half}}({\mathit{half}}, 0, M_1) : M_1]`. |
| |
| #. Let :math:`{{\mathit{ci}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M_2}}(c_2){}[{\mathrm{half}}({\mathit{half}}, 0, M_1) : M_1]`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{M_1}}({{{\mathrm{imul}}}_{N_1}({{{{\mathrm{extend}}}_{N_2, N_1}^{{\mathit{sx}}}}}{({\mathit{ci}}_1)}, {{{{\mathrm{extend}}}_{N_2, N_1}^{{\mathit{sx}}}}}{({\mathit{ci}}_2)})^\ast})`. |
| |
| #. Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vextbinop}} = `. |
| |
| #. Let :math:`{{\mathit{ci}}_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M_2}}(c_1)`. |
| |
| #. Let :math:`{{\mathit{ci}}_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{n}}_2}{\mathsf{x}}{M_2}}(c_2)`. |
| |
| #. Let :math:`{{\mathit{cj}}_1~{\mathit{cj}}_2^\ast}` be the result for which the :ref:`concatenation <notation-concat>` of :math:`{{\mathit{cj}}_1~{\mathit{cj}}_2^\ast}` is :math:`{{{\mathrm{imul}}}_{N_1}({{{{\mathrm{extend}}}_{N_2, N_1}^{\mathsf{s}}}}{({\mathit{ci}}_1)}, {{{{\mathrm{extend}}}_{N_2, N_1}^{\mathsf{s}}}}{({\mathit{ci}}_2)})^\ast}`. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inv}}_{{\mathit{lanes}}}}_{{{{\mathsf{i}}{n}}_1}{\mathsf{x}}{M_1}}({{{\mathrm{iadd}}}_{N_1}({\mathit{cj}}_1, {\mathit{cj}}_2)^\ast})`. |
| |
| #. Return :math:`c`. |
| |
| |
| :math:`{{{\mathit{vshiftop}}}{\mathsf{\_}}~{{\mathsf{i}}{n}}{\mathsf{x}}{M}}{({\mathit{lane}}, n)}` |
| ................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{vshiftop}} = \mathsf{shl}`, then: |
| |
| a. Return :math:`{{\mathrm{ishl}}}_{N}({\mathit{lane}}, n)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vshiftop}}` is some :math:`\mathsf{shr}~{\mathit{sx}}`. |
| |
| #. Let :math:`(\mathsf{shr}~{\mathit{sx}})` be the destructuring of :math:`{\mathit{vshiftop}}`. |
| |
| #. Return :math:`{{{{\mathrm{ishr}}}_{N}^{{\mathit{sx}}}}}{({\mathit{lane}}, n)}`. |
| |
| |
| :math:`{{\mathrm{default}}}_{{\mathit{valtype}}}` |
| ................................................. |
| |
| |
| 1. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{i{\scriptstyle 64}}`, then: |
| |
| a. Return :math:`(\mathsf{i{\scriptstyle 64}}{.}\mathsf{const}~0)`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`(\mathsf{f{\scriptstyle 32}}{.}\mathsf{const}~{+0})`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{f{\scriptstyle 64}}`, then: |
| |
| a. Return :math:`(\mathsf{f{\scriptstyle 64}}{.}\mathsf{const}~{+0})`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{v{\scriptstyle 128}}`, then: |
| |
| a. Return :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~0)`. |
| |
| #. If :math:`{\mathit{valtype}} = \mathsf{funcref}`, then: |
| |
| a. Return :math:`(\mathsf{ref{.}null}~\mathsf{funcref})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}} = \mathsf{externref}`. |
| |
| #. Return :math:`(\mathsf{ref{.}null}~\mathsf{externref})`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{func}~{\mathit{funcaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{global}~{\mathit{globaladdr}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{table}~{\mathit{tableaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{mem}~{\mathit{memaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{xv}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{xv}}^\ast})`. |
| |
| |
| :math:`(s, f){.}\mathsf{store}` |
| ............................... |
| |
| |
| 1. Return. |
| |
| |
| :math:`(s, f){.}\mathsf{frame}` |
| ............................... |
| |
| |
| 1. Return :math:`f`. |
| |
| |
| :math:`(s, f){.}\mathsf{module}{.}\mathsf{funcs}` |
| ................................................. |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}{.}\mathsf{funcs}`. |
| |
| |
| :math:`(s, f){.}\mathsf{funcs}` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{funcs}`. |
| |
| |
| :math:`(s, f){.}\mathsf{globals}` |
| ................................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{globals}`. |
| |
| |
| :math:`(s, f){.}\mathsf{tables}` |
| ................................ |
| |
| |
| 1. Return :math:`s{.}\mathsf{tables}`. |
| |
| |
| :math:`(s, f){.}\mathsf{mems}` |
| .............................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{mems}`. |
| |
| |
| :math:`(s, f){.}\mathsf{elems}` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{elems}`. |
| |
| |
| :math:`(s, f){.}\mathsf{datas}` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{datas}`. |
| |
| |
| :math:`(s, f){.}\mathsf{module}` |
| ................................ |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}`. |
| |
| |
| :math:`(s, f){.}\mathsf{types}{}[x]` |
| .................................... |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}{.}\mathsf{types}{}[x]`. |
| |
| |
| :math:`(s, f){.}\mathsf{funcs}{}[x]` |
| .................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{funcs}{}[f{.}\mathsf{module}{.}\mathsf{funcs}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{globals}{}[x]` |
| ...................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{globals}{}[f{.}\mathsf{module}{.}\mathsf{globals}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{tables}{}[x]` |
| ..................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{mems}{}[x]` |
| ................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{elems}{}[x]` |
| .................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{elems}{}[f{.}\mathsf{module}{.}\mathsf{elems}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{datas}{}[x]` |
| .................................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{datas}{}[f{.}\mathsf{module}{.}\mathsf{datas}{}[x]]`. |
| |
| |
| :math:`(s, f){.}\mathsf{locals}{}[x]` |
| ..................................... |
| |
| |
| 1. Return :math:`f{.}\mathsf{locals}{}[x]`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{locals}{}[x] = v]` |
| ............................................. |
| |
| |
| 1. Replace :math:`f{.}\mathsf{locals}{}[x]` with :math:`v`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{globals}{}[x]{.}\mathsf{value} = v]` |
| ............................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{globals}{}[f{.}\mathsf{module}{.}\mathsf{globals}{}[x]]{.}\mathsf{value}` with :math:`v`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i] = r]` |
| .................................................................. |
| |
| |
| 1. Replace :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]{.}\mathsf{refs}{}[i]` with :math:`r`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{tables}{}[x] = {\mathit{ti}}]` |
| ......................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]` with :math:`{\mathit{ti}}`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i : j] = {b^\ast}]` |
| ............................................................................ |
| |
| |
| 1. Replace :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]{.}\mathsf{bytes}{}[i : j]` with :math:`{b^\ast}`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{mems}{}[x] = {\mathit{mi}}]` |
| ....................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]` with :math:`{\mathit{mi}}`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{elems}{}[x]{.}\mathsf{refs} = {r^\ast}]` |
| ................................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{elems}{}[f{.}\mathsf{module}{.}\mathsf{elems}{}[x]]{.}\mathsf{refs}` with :math:`{r^\ast}`. |
| |
| |
| :math:`(s, f){}[{.}\mathsf{datas}{}[x]{.}\mathsf{bytes} = {b^\ast}]` |
| .................................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{datas}{}[f{.}\mathsf{module}{.}\mathsf{datas}{}[x]]{.}\mathsf{bytes}` with :math:`{b^\ast}`. |
| |
| |
| :math:`{\mathrm{growtable}}({\mathit{ti}}, n, r)` |
| ................................................. |
| |
| |
| 1. Let :math:`\{ \mathsf{type}~({}[ i .. {j^?} ]~{\mathit{rt}}),\;\allowbreak \mathsf{refs}~{{r'}^\ast} \}` be the destructuring of :math:`{\mathit{ti}}`. |
| |
| #. Let :math:`{i'}` be :math:`{|{{r'}^\ast}|} + n`. |
| |
| #. If :math:`{({i'} \leq j)^?}`, then: |
| |
| a. Let :math:`{\mathit{ti}'}` be the table instance :math:`\{ \mathsf{type}~({}[ {i'} .. {j^?} ]~{\mathit{rt}}),\;\allowbreak \mathsf{refs}~{{r'}^\ast}~{r^{n}} \}`. |
| |
| #. Return :math:`{\mathit{ti}'}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{growmemory}}({\mathit{mi}}, n)` |
| ............................................... |
| |
| |
| 1. Let :math:`\{ \mathsf{type}~{}[ i .. {j^?} ]~\mathsf{page},\;\allowbreak \mathsf{bytes}~{b^\ast} \}` be the destructuring of :math:`{\mathit{mi}}`. |
| |
| #. Let :math:`{i'}` be :math:`{|{b^\ast}|} / (64 \, {\mathrm{Ki}}) + n`. |
| |
| #. If :math:`{({i'} \leq j)^?}`, then: |
| |
| a. Let :math:`{\mathit{mi}'}` be the memory instance :math:`\{ \mathsf{type}~{}[ {i'} .. {j^?} ]~\mathsf{page},\;\allowbreak \mathsf{bytes}~{b^\ast}~{\mathtt{0x00}^{n \cdot 64 \, {\mathrm{Ki}}}} \}`. |
| |
| #. Return :math:`{\mathit{mi}'}`. |
| |
| #. Fail. |
| |
| |
| :math:`{{\mathrm{blocktype}}}_{z}({\mathit{blocktype}})` |
| ........................................................ |
| |
| |
| 1. If :math:`{\mathit{blocktype}} = ()`, then: |
| |
| a. Return :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| #. If :math:`{\mathit{blocktype}}` is some :math:`{{\mathit{valtype}}^?}`, then: |
| |
| a. Let :math:`{{\mathit{valtype}}_0^?}` be the block type :math:`{\mathit{blocktype}}`. |
| |
| #. If :math:`{{\mathit{valtype}}_0^?}` is defined, then: |
| |
| 1) Let :math:`t` be :math:`{{\mathit{valtype}}_0^?}`. |
| |
| #) Return :math:`\epsilon~\rightarrow~t`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{blocktype}}` is some :math:`{\mathit{typeidx}}`. |
| |
| #. Let :math:`x` be the block type :math:`{\mathit{blocktype}}`. |
| |
| #. Return :math:`z{.}\mathsf{types}{}[x]`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externaddr}''}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{func}~{\mathit{funcaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externaddr}''}^\ast})` |
| .......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{global}~{\mathit{globaladdr}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externaddr}''}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{table}~{\mathit{tableaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externaddr}''}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{mem}~{\mathit{memaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}''}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{allocfunc}}(s, {\mathit{moduleinst}}, {\mathit{func}})` |
| ....................................................................... |
| |
| |
| 1. Let :math:`(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}})` be the destructuring of :math:`{\mathit{func}}`. |
| |
| #. Let :math:`{\mathit{fi}}` be the function instance :math:`\{ \mathsf{type}~{\mathit{moduleinst}}{.}\mathsf{types}{}[x],\;\allowbreak \mathsf{module}~{\mathit{moduleinst}},\;\allowbreak \mathsf{code}~{\mathit{func}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{funcs}`. |
| |
| #. Append :math:`{\mathit{fi}}` to :math:`s{.}\mathsf{funcs}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocfuncs}}(s, {\mathit{moduleinst}}, {{\mathit{func}''}^\ast})` |
| ................................................................................. |
| |
| |
| 1. If :math:`{{\mathit{func}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{func}}~{{\mathit{func}'}^\ast}` be :math:`{{\mathit{func}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{fa}}` be :math:`{\mathrm{allocfunc}}(s, {\mathit{moduleinst}}, {\mathit{func}})`. |
| |
| #. Let :math:`{{\mathit{fa}'}^\ast}` be :math:`{\mathrm{allocfuncs}}(s, {\mathit{moduleinst}}, {{\mathit{func}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{fa}}~{{\mathit{fa}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocglobal}}(s, {\mathit{globaltype}}, {\mathit{val}})` |
| ........................................................................ |
| |
| |
| 1. Let :math:`{\mathit{gi}}` be the global instance :math:`\{ \mathsf{type}~{\mathit{globaltype}},\;\allowbreak \mathsf{value}~{\mathit{val}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{globals}`. |
| |
| #. Append :math:`{\mathit{gi}}` to :math:`s{.}\mathsf{globals}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocglobals}}(s, {{\mathit{globaltype}''}^\ast}, {{\mathit{val}''}^\ast})` |
| ........................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{globaltype}''}^\ast} = \epsilon`, then: |
| |
| a. Assert: :math:`{{\mathit{val}''}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{globaltype}}~{{\mathit{globaltype}'}^\ast}` be :math:`{{\mathit{globaltype}''}^\ast}`. |
| |
| #. Assert: :math:`{|{{\mathit{val}''}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{val}}~{{\mathit{val}'}^\ast}` be :math:`{{\mathit{val}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ga}}` be :math:`{\mathrm{allocglobal}}(s, {\mathit{globaltype}}, {\mathit{val}})`. |
| |
| #. Let :math:`{{\mathit{ga}'}^\ast}` be :math:`{\mathrm{allocglobals}}(s, {{\mathit{globaltype}'}^\ast}, {{\mathit{val}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{ga}}~{{\mathit{ga}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{alloctable}}(s, {}[ i .. {j^?} ]~{\mathit{rt}})` |
| ................................................................ |
| |
| |
| 1. Let :math:`{\mathit{ti}}` be the table instance :math:`\{ \mathsf{type}~({}[ i .. {j^?} ]~{\mathit{rt}}),\;\allowbreak \mathsf{refs}~{(\mathsf{ref{.}null}~{\mathit{rt}})^{i}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{tables}`. |
| |
| #. Append :math:`{\mathit{ti}}` to :math:`s{.}\mathsf{tables}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{alloctables}}(s, {{\mathit{tabletype}''}^\ast})` |
| ................................................................ |
| |
| |
| 1. If :math:`{{\mathit{tabletype}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{tabletype}}~{{\mathit{tabletype}'}^\ast}` be :math:`{{\mathit{tabletype}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ta}}` be :math:`{\mathrm{alloctable}}(s, {\mathit{tabletype}})`. |
| |
| #. Let :math:`{{\mathit{ta}'}^\ast}` be :math:`{\mathrm{alloctables}}(s, {{\mathit{tabletype}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{ta}}~{{\mathit{ta}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocmem}}(s, {}[ i .. {j^?} ]~\mathsf{page})` |
| .............................................................. |
| |
| |
| 1. Let :math:`{\mathit{mi}}` be the memory instance :math:`\{ \mathsf{type}~{}[ i .. {j^?} ]~\mathsf{page},\;\allowbreak \mathsf{bytes}~{\mathtt{0x00}^{i \cdot 64 \, {\mathrm{Ki}}}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{mems}`. |
| |
| #. Append :math:`{\mathit{mi}}` to :math:`s{.}\mathsf{mems}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocmems}}(s, {{\mathit{memtype}''}^\ast})` |
| ............................................................ |
| |
| |
| 1. If :math:`{{\mathit{memtype}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{memtype}}~{{\mathit{memtype}'}^\ast}` be :math:`{{\mathit{memtype}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ma}}` be :math:`{\mathrm{allocmem}}(s, {\mathit{memtype}})`. |
| |
| #. Let :math:`{{\mathit{ma}'}^\ast}` be :math:`{\mathrm{allocmems}}(s, {{\mathit{memtype}'}^\ast})`. |
| |
| #. Return :math:`{\mathit{ma}}~{{\mathit{ma}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocelem}}(s, {\mathit{rt}}, {{\mathit{ref}}^\ast})` |
| ..................................................................... |
| |
| |
| 1. Let :math:`{\mathit{ei}}` be the element instance :math:`\{ \mathsf{type}~{\mathit{rt}},\;\allowbreak \mathsf{refs}~{{\mathit{ref}}^\ast} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{elems}`. |
| |
| #. Append :math:`{\mathit{ei}}` to :math:`s{.}\mathsf{elems}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocelems}}(s, {{\mathit{reftype}}^\ast}, {{\mathit{ref}''}^\ast})` |
| .................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{ref}''}^\ast} = \epsilon`, then: |
| |
| a. Assert: :math:`{{\mathit{reftype}}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{{\mathit{ref}}^\ast}~{{{\mathit{ref}'}^\ast}^\ast}` be :math:`{{\mathit{ref}''}^\ast}`. |
| |
| #. Assert: :math:`{|{{\mathit{reftype}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{rt}}~{{\mathit{rt}'}^\ast}` be :math:`{{\mathit{reftype}}^\ast}`. |
| |
| #. Let :math:`{\mathit{ea}}` be :math:`{\mathrm{allocelem}}(s, {\mathit{rt}}, {{\mathit{ref}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ea}'}^\ast}` be :math:`{\mathrm{allocelems}}(s, {{\mathit{rt}'}^\ast}, {{{\mathit{ref}'}^\ast}^\ast})`. |
| |
| #. Return :math:`{\mathit{ea}}~{{\mathit{ea}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocdata}}(s, {{\mathit{byte}}^\ast})` |
| ....................................................... |
| |
| |
| 1. Let :math:`{\mathit{di}}` be the data instance :math:`\{ \mathsf{bytes}~{{\mathit{byte}}^\ast} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{datas}`. |
| |
| #. Append :math:`{\mathit{di}}` to :math:`s{.}\mathsf{datas}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{\mathrm{allocdatas}}(s, {{\mathit{byte}''}^\ast})` |
| .......................................................... |
| |
| |
| 1. If :math:`{{\mathit{byte}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{{\mathit{byte}}^\ast}~{{{\mathit{byte}'}^\ast}^\ast}` be :math:`{{\mathit{byte}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{da}}` be :math:`{\mathrm{allocdata}}(s, {{\mathit{byte}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{da}'}^\ast}` be :math:`{\mathrm{allocdatas}}(s, {{{\mathit{byte}'}^\ast}^\ast})`. |
| |
| #. Return :math:`{\mathit{da}}~{{\mathit{da}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{instexport}}({{\mathit{fa}}^\ast}, {{\mathit{ga}}^\ast}, {{\mathit{ta}}^\ast}, {{\mathit{ma}}^\ast}, \mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` |
| ........................................................................................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{func}~{\mathit{funcidx}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{func}~{{\mathit{fa}}^\ast}{}[x]) \}`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{global}~{\mathit{globalidx}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{global}~{{\mathit{ga}}^\ast}{}[x]) \}`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{table}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{table}~{{\mathit{ta}}^\ast}{}[x]) \}`. |
| |
| #. Assert: :math:`{\mathit{externidx}}` is some :math:`\mathsf{mem}~{\mathit{memidx}}`. |
| |
| #. Let :math:`(\mathsf{mem}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{mem}~{{\mathit{ma}}^\ast}{}[x]) \}`. |
| |
| |
| :math:`{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}^\ast}, {{{\mathit{ref}}^\ast}^\ast})` |
| ....................................................................................................................................... |
| |
| |
| 1. Let :math:`(\mathsf{module}~{{\mathit{type}}_0^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^{n_{\mathit{func}}}}~{{\mathit{global}}_1^\ast}~{{\mathit{table}}_2^\ast}~{{\mathit{mem}}_3^\ast}~{{\mathit{elem}}_4^\ast}~{{\mathit{data}}_5^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be the destructuring of :math:`{\mathit{module}}`. |
| |
| #. Let :math:`{(\mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}})^{n_{\mathit{data}}}}` be :math:`{{\mathit{data}}_5^\ast}`. |
| |
| #. Let :math:`{(\mathsf{elem}~{\mathit{rt}}~{{\mathit{expr}}_2^\ast}~{\mathit{elemmode}})^{n_{\mathit{elem}}}}` be :math:`{{\mathit{elem}}_4^\ast}`. |
| |
| #. Let :math:`{(\mathsf{memory}~{\mathit{memtype}})^{n_{\mathit{mem}}}}` be :math:`{{\mathit{mem}}_3^\ast}`. |
| |
| #. Let :math:`{(\mathsf{table}~{\mathit{tabletype}})^{n_{\mathit{table}}}}` be :math:`{{\mathit{table}}_2^\ast}`. |
| |
| #. Let :math:`{(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_1)^{n_{\mathit{global}}}}` be :math:`{{\mathit{global}}_1^\ast}`. |
| |
| #. Let :math:`{{\mathit{ft}}^\ast}` be the function type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{type}}_0` in :math:`{{\mathit{type}}_0^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{type}~{\mathit{ft}})` be the destructuring of :math:`{\mathit{type}}_0`. |
| |
| #. Append :math:`{\mathit{ft}}` to :math:`{{\mathit{ft}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{fa}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ga}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ma}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ta}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{fa}}^\ast}` be :math:`{|s{.}\mathsf{funcs}|} + i_{\mathit{func}}` for all :math:`i_{\mathit{func}}` from :math:`0` to :math:`n_{\mathit{func}} - 1`. |
| |
| #. Let :math:`{{\mathit{ga}}^\ast}` be :math:`{|s{.}\mathsf{globals}|} + i_{\mathit{global}}` for all :math:`i_{\mathit{global}}` from :math:`0` to :math:`n_{\mathit{global}} - 1`. |
| |
| #. Let :math:`{{\mathit{ta}}^\ast}` be :math:`{|s{.}\mathsf{tables}|} + i_{\mathit{table}}` for all :math:`i_{\mathit{table}}` from :math:`0` to :math:`n_{\mathit{table}} - 1`. |
| |
| #. Let :math:`{{\mathit{ma}}^\ast}` be :math:`{|s{.}\mathsf{mems}|} + i_{\mathit{mem}}` for all :math:`i_{\mathit{mem}}` from :math:`0` to :math:`n_{\mathit{mem}} - 1`. |
| |
| #. Let :math:`{{\mathit{ea}}^\ast}` be :math:`{|s{.}\mathsf{elems}|} + i_{\mathit{elem}}` for all :math:`i_{\mathit{elem}}` from :math:`0` to :math:`n_{\mathit{elem}} - 1`. |
| |
| #. Let :math:`{{\mathit{da}}^\ast}` be :math:`{|s{.}\mathsf{datas}|} + i_{\mathit{data}}` for all :math:`i_{\mathit{data}}` from :math:`0` to :math:`n_{\mathit{data}} - 1`. |
| |
| #. Let :math:`{{\mathit{xi}}^\ast}` be the export instance sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{export}}` in :math:`{{\mathit{export}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{xi}}` be the export instance :math:`{\mathrm{instexport}}({{\mathit{fa}}_{\mathit{ex}}^\ast}~{{\mathit{fa}}^\ast}, {{\mathit{ga}}_{\mathit{ex}}^\ast}~{{\mathit{ga}}^\ast}, {{\mathit{ta}}_{\mathit{ex}}^\ast}~{{\mathit{ta}}^\ast}, {{\mathit{ma}}_{\mathit{ex}}^\ast}~{{\mathit{ma}}^\ast}, {\mathit{export}})`. |
| |
| #. Append :math:`{\mathit{xi}}` to :math:`{{\mathit{xi}}^\ast}`. |
| |
| #. Let :math:`{\mathit{moduleinst}}` be the module instance :math:`\{ \mathsf{types}~{{\mathit{ft}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{fa}}_{\mathit{ex}}^\ast}~{{\mathit{fa}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{ga}}_{\mathit{ex}}^\ast}~{{\mathit{ga}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{ta}}_{\mathit{ex}}^\ast}~{{\mathit{ta}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{ma}}_{\mathit{ex}}^\ast}~{{\mathit{ma}}^\ast},\;\allowbreak \mathsf{elems}~{{\mathit{ea}}^\ast},\;\allowbreak \mathsf{datas}~{{\mathit{da}}^\ast},\;\allowbreak \mathsf{exports}~{{\mathit{xi}}^\ast} \}`. |
| |
| #. Let :math:`{{\mathit{funcaddr}}_0^\ast}` be :math:`{\mathrm{allocfuncs}}(s, {\mathit{moduleinst}}, {{\mathit{func}}^{n_{\mathit{func}}}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{funcaddr}}_0^\ast} = {{\mathit{fa}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{globaladdr}}_0^\ast}` be :math:`{\mathrm{allocglobals}}(s, {{\mathit{globaltype}}^{n_{\mathit{global}}}}, {{\mathit{val}}^\ast})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{globaladdr}}_0^\ast} = {{\mathit{ga}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{tableaddr}}_0^\ast}` be :math:`{\mathrm{alloctables}}(s, {{\mathit{tabletype}}^{n_{\mathit{table}}}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{tableaddr}}_0^\ast} = {{\mathit{ta}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{memaddr}}_0^\ast}` be :math:`{\mathrm{allocmems}}(s, {{\mathit{memtype}}^{n_{\mathit{mem}}}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{memaddr}}_0^\ast} = {{\mathit{ma}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{elemaddr}}_0^\ast}` be :math:`{\mathrm{allocelems}}(s, {{\mathit{rt}}^{n_{\mathit{elem}}}}, {{{\mathit{ref}}^\ast}^\ast})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{elemaddr}}_0^\ast} = {{\mathit{ea}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{dataaddr}}_0^\ast}` be :math:`{\mathrm{allocdatas}}(s, {({{\mathit{byte}}^\ast})^{n_{\mathit{data}}}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{dataaddr}}_0^\ast} = {{\mathit{da}}^\ast}`. |
| |
| #. Return :math:`{\mathit{moduleinst}}`. |
| |
| |
| :math:`{\mathrm{runelem}}(\mathsf{elem}~{\mathit{reftype}}~{{\mathit{expr}}^\ast}~{\mathit{elemmode}}, i)` |
| .......................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{elemmode}} = \mathsf{passive}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{\mathit{elemmode}} = \mathsf{declare}`, then: |
| |
| a. Return :math:`(\mathsf{elem{.}drop}~i)`. |
| |
| #. Assert: :math:`{\mathit{elemmode}}` is some :math:`\mathsf{active}~{\mathit{tableidx}}~{\mathit{expr}}`. |
| |
| #. Let :math:`(\mathsf{active}~x~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{elemmode}}`. |
| |
| #. Let :math:`n` be the length of :math:`{{\mathit{expr}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{instr}}^\ast}~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)~(\mathsf{table{.}init}~x~i)~(\mathsf{elem{.}drop}~i)`. |
| |
| |
| :math:`{\mathrm{rundata}}(\mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}}, i)` |
| ....................................................................................... |
| |
| |
| 1. If :math:`{\mathit{datamode}} = \mathsf{passive}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Assert: :math:`{\mathit{datamode}}` is some :math:`\mathsf{active}~{\mathit{memidx}}~{\mathit{expr}}`. |
| |
| #. Let :math:`(\mathsf{active}~{\mathit{memidx}}_0~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{datamode}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{memidx}}_0 = 0`. |
| |
| #. Let :math:`n` be the length of :math:`{{\mathit{byte}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{instr}}^\ast}~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)~(\mathsf{memory{.}init}~i)~(\mathsf{data{.}drop}~i)`. |
| |
| |
| :math:`{\mathrm{instantiate}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast})` |
| .................................................................................. |
| |
| |
| 1. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be the destructuring of :math:`{\mathit{module}}`. |
| |
| #. Let :math:`{{\mathit{functype}}^\ast}` be the function type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{type}}` in :math:`{{\mathit{type}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{type}~{\mathit{functype}})` be the destructuring of :math:`{\mathit{type}}`. |
| |
| #. Append :math:`{\mathit{functype}}` to :math:`{{\mathit{functype}}^\ast}`. |
| |
| #. Let :math:`n_{\mathsf{d}}` be the length of :math:`{{\mathit{data}}^\ast}`. |
| |
| #. Let :math:`n_{\mathsf{e}}` be the length of :math:`{{\mathit{elem}}^\ast}`. |
| |
| #. Let :math:`n_{\mathsf{f}}` be the length of :math:`{{\mathit{func}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}` be the expression sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{global}}` in :math:`{{\mathit{global}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_{\mathsf{g}})` be the destructuring of :math:`{\mathit{global}}`. |
| |
| #. Append :math:`{\mathit{expr}}_{\mathsf{g}}` to :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}`. |
| |
| #. Let :math:`{{{\mathit{expr}}_{\mathsf{e}}^\ast}^\ast}` be the expression sequence sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{elem}}` in :math:`{{\mathit{elem}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{elem}~{\mathit{reftype}}~{{\mathit{expr}}_{\mathsf{e}}^\ast}~{\mathit{elemmode}})` be the destructuring of :math:`{\mathit{elem}}`. |
| |
| #. Append :math:`{{\mathit{expr}}_{\mathsf{e}}^\ast}` to :math:`{{{\mathit{expr}}_{\mathsf{e}}^\ast}^\ast}`. |
| |
| #. Let :math:`{{\mathit{instr}}_{\mathsf{d}}^\ast}` be the :ref:`concatenation <notation-concat>` of :math:`{{\mathrm{rundata}}({{\mathit{data}}^\ast}{}[j], j)^{j<n_{\mathsf{d}}}}`. |
| |
| #. Let :math:`{{\mathit{instr}}_{\mathsf{e}}^\ast}` be the :ref:`concatenation <notation-concat>` of :math:`{{\mathrm{runelem}}({{\mathit{elem}}^\ast}{}[i], i)^{i<n_{\mathsf{e}}}}`. |
| |
| #. Let :math:`{\mathit{moduleinst}}_{\mathit{init}}` be the module instance :math:`\{ \mathsf{types}~{{\mathit{functype}}^\ast},\;\allowbreak \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})~{({|s{.}\mathsf{funcs}|} + i_{\mathsf{f}})^{i_{\mathsf{f}}<n_{\mathsf{f}}}},\;\allowbreak \mathsf{globals}~{\mathrm{globals}}({{\mathit{externaddr}}^\ast}) \}`. |
| |
| #. Let :math:`f_{\mathit{init}}` be the frame :math:`\{ \mathsf{module}~{\mathit{moduleinst}}_{\mathit{init}} \}`. |
| |
| #. Let :math:`z` be the state :math:`(s, f_{\mathit{init}})`. |
| |
| #. Let :math:`F` be the :math:`\mathsf{frame}` :math:`z{.}\mathsf{frame}`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`F`. |
| |
| #. Let :math:`{{\mathit{val}}^\ast}` be the value sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{expr}}_{\mathsf{g}}` in :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{val}}` be the result of :ref:`evaluating <exec-expr>` :math:`{\mathit{expr}}_{\mathsf{g}}` with state :math:`z`. |
| |
| #. Append :math:`{\mathit{val}}` to :math:`{{\mathit{val}}^\ast}`. |
| |
| #. Let :math:`{{{\mathit{ref}}^\ast}^\ast}` be the reference sequence sequence :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{expr}}_{\mathsf{e}}^\ast}` in :math:`{{{\mathit{expr}}_{\mathsf{e}}^\ast}^\ast}`, do: |
| |
| a. Let :math:`{{\mathit{ref}}^\ast}` be the reference sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{expr}}_{\mathsf{e}}` in :math:`{{\mathit{expr}}_{\mathsf{e}}^\ast}`, do: |
| |
| 1) Let :math:`{\mathit{ref}}` be the result of :ref:`evaluating <exec-expr>` :math:`{\mathit{expr}}_{\mathsf{e}}` with state :math:`z`. |
| |
| #) Append :math:`{\mathit{ref}}` to :math:`{{\mathit{ref}}^\ast}`. |
| |
| #. Append :math:`{{\mathit{ref}}^\ast}` to :math:`{{{\mathit{ref}}^\ast}^\ast}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Let :math:`{\mathit{moduleinst}}` be :math:`{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}^\ast}, {{{\mathit{ref}}^\ast}^\ast})`. |
| |
| #. Let :math:`f` be the frame :math:`\{ \mathsf{module}~{\mathit{moduleinst}} \}`. |
| |
| #. Let :math:`{f'}` be the :math:`\mathsf{frame}` :math:`f`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{f'}`. |
| |
| #. Execute the sequence :math:`{{\mathit{instr}}_{\mathsf{e}}^\ast}`. |
| |
| #. Execute the sequence :math:`{{\mathit{instr}}_{\mathsf{d}}^\ast}`. |
| |
| #. If :math:`{{\mathit{start}}^?}` is defined, then: |
| |
| a. Let :math:`(\mathsf{start}~x)` be :math:`{{\mathit{start}}^?}`. |
| |
| #. Let :math:`{\mathit{instr}}_0` be the administrative instruction :math:`(\mathsf{call}~x)`. |
| |
| #. Execute the instruction :math:`{\mathit{instr}}_0`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Return :math:`f{.}\mathsf{module}`. |
| |
| |
| :math:`{\mathrm{invoke}}(s, {\mathit{fa}}, {{\mathit{val}}^{n}})` |
| ................................................................. |
| |
| |
| 1. Let :math:`f` be the frame :math:`\{ \mathsf{module}~\{ \} \}`. |
| |
| #. Let :math:`F` be the :math:`\mathsf{frame}` :math:`(s, f)`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`F`. |
| |
| #. Let :math:`{t_1^{n}}~\rightarrow~{t_2^\ast}` be the destructuring of :math:`(s, f){.}\mathsf{funcs}{}[{\mathit{fa}}]{.}\mathsf{type}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Let :math:`k` be the length of :math:`{t_2^\ast}`. |
| |
| #. Let :math:`{f'}` be the :math:`\mathsf{frame}` :math:`f` whose arity is :math:`k`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{f'}`. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{call}~{\mathit{fa}})`. |
| |
| #. Pop the values :math:`{{\mathit{val}'}^{k}}` from the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Return :math:`{{\mathit{val}'}^{k}}`. |
| |
| |
| :math:`\mathsf{eval\_expr}~{{\mathit{instr}}^\ast}` |
| ................................................... |
| |
| |
| 1. Execute the sequence :math:`{{\mathit{instr}}^\ast}`. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Return :math:`{\mathit{val}}`. |
| |
| |
| == Complete. |
| spectec 0.5 generator |
| == Parsing... |
| == Elaboration... |
| == IL Validation... |
| == Running pass sideconditions... |
| == IL Validation after pass sideconditions... |
| == Translating to AL... |
| == Prose Generation... |
| Limits_ok |
| - the limits ([ n .. m? ]) is valid with k if: |
| - n is less than or equal to k. |
| - If m is defined, then: |
| - n is less than or equal to m. |
| - m is less than or equal to k. |
| |
| Functype_ok |
| - the function type t_1* -> t_2* is always valid. |
| |
| Globaltype_ok |
| - the global type (MUT? t) is always valid. |
| |
| Tabletype_ok |
| - the table type (limits reftype) is valid if: |
| - the limits limits is valid with ((2 ^ 32) - 1). |
| |
| Memtype_ok |
| - the memory type limits PAGE is valid if: |
| - the limits limits is valid with (2 ^ 16). |
| |
| Externtype_ok |
| - the external type externtype is valid if: |
| - Either: |
| - externtype is (FUNC functype). |
| - the function type functype is valid. |
| - Or: |
| - externtype is (GLOBAL globaltype). |
| - the global type globaltype is valid. |
| - Or: |
| - externtype is (TABLE tabletype). |
| - the table type tabletype is valid. |
| - Or: |
| - externtype is (MEM memtype). |
| - the memory type memtype is valid. |
| |
| Externtype_ok/func |
| - the external type (FUNC functype) is valid if: |
| - the function type functype is valid. |
| |
| Externtype_ok/global |
| - the external type (GLOBAL globaltype) is valid if: |
| - the global type globaltype is valid. |
| |
| Externtype_ok/table |
| - the external type (TABLE tabletype) is valid if: |
| - the table type tabletype is valid. |
| |
| Externtype_ok/mem |
| - the external type (MEM memtype) is valid if: |
| - the memory type memtype is valid. |
| |
| Valtype_sub |
| - the value type t_2 matches the value type t_1 if: |
| - Either: |
| - t_2 is t_1. |
| - Or: |
| - t_2 is BOT. |
| |
| Valtype_sub/refl |
| - the value type t matches only itself. |
| |
| Valtype_sub/bot |
| - the value type BOT matches t. |
| |
| Resulttype_sub |
| - the result type t_1* matches the result type t_2* if: |
| - For all t_1 in t_1*, and corresponding t_2 in t_2*: |
| - the value type t_1 matches the value type t_2. |
| |
| Limits_sub |
| - the limits ([ n_11 .. ?(n_12) ]) matches the limits ([ n_21 .. ?(n_22) ]) if: |
| - n_11 is greater than or equal to n_21. |
| - n_12 is less than or equal to n_22. |
| |
| Functype_sub |
| - the function type ft matches only itself. |
| |
| Globaltype_sub |
| - the global type gt matches only itself. |
| |
| Tabletype_sub |
| - the table type (lim_1 rt) matches the table type (lim_2 rt) if: |
| - the limits lim_1 matches the limits lim_2. |
| |
| Memtype_sub |
| - the memory type lim_1 PAGE matches the memory type lim_2 PAGE if: |
| - the limits lim_1 matches the limits lim_2. |
| |
| Externtype_sub |
| - the external type externtype_1 matches the external type externtype_2 if: |
| - Either: |
| - externtype_1 is (FUNC ft_1). |
| - externtype_2 is (FUNC ft_2). |
| - the function type ft_1 matches the function type ft_2. |
| - Or: |
| - externtype_1 is (GLOBAL gt_1). |
| - externtype_2 is (GLOBAL gt_2). |
| - the global type gt_1 matches the global type gt_2. |
| - Or: |
| - externtype_1 is (TABLE tt_1). |
| - externtype_2 is (TABLE tt_2). |
| - the table type tt_1 matches the table type tt_2. |
| - Or: |
| - externtype_1 is (MEM mt_1). |
| - externtype_2 is (MEM mt_2). |
| - the memory type mt_1 matches the memory type mt_2. |
| |
| Externtype_sub/func |
| - the external type (FUNC ft_1) matches the external type (FUNC ft_2) if: |
| - the function type ft_1 matches the function type ft_2. |
| |
| Externtype_sub/global |
| - the external type (GLOBAL gt_1) matches the external type (GLOBAL gt_2) if: |
| - the global type gt_1 matches the global type gt_2. |
| |
| Externtype_sub/table |
| - the external type (TABLE tt_1) matches the external type (TABLE tt_2) if: |
| - the table type tt_1 matches the table type tt_2. |
| |
| Externtype_sub/mem |
| - the external type (MEM mt_1) matches the external type (MEM mt_2) if: |
| - the memory type mt_1 matches the memory type mt_2. |
| |
| Blocktype_ok |
| - the block type blocktype is valid with the function type valtype* -> valtype'* if: |
| - Either: |
| - blocktype is (_RESULT valtype''?). |
| - the value type sequence valtype* is []. |
| - the value type sequence valtype'* is valtype''?. |
| - Or: |
| - blocktype is (_IDX typeidx). |
| - the function type C.TYPES[typeidx] exists. |
| - C.TYPES[typeidx] is valtype* -> valtype'*. |
| |
| Blocktype_ok/valtype |
| - the block type (_RESULT valtype?) is valid with the function type [] -> valtype?. |
| |
| Blocktype_ok/typeidx |
| - the block type (_IDX typeidx) is valid with the function type t_1* -> t_2* if: |
| - the function type C.TYPES[typeidx] exists. |
| - C.TYPES[typeidx] is t_1* -> t_2*. |
| |
| Instr_ok/nop |
| - the instruction NOP is valid with the function type [] -> []. |
| |
| Instr_ok/unreachable |
| - the instruction UNREACHABLE is valid with t_1* -> t_2*. |
| |
| Instr_ok/drop |
| - the instruction DROP is valid with the function type [t] -> []. |
| |
| Instr_ok/select |
| - the instruction (SELECT valtype?) is valid with the function type [t, t, I32] -> [t] if: |
| - Either: |
| - the value type sequence valtype? is ?([t]). |
| - Or: |
| - valtype? is ?(). |
| - the value type t matches the value type t'. |
| - t' is numtype or t' is vectype. |
| |
| Instr_ok/block |
| - the instruction (BLOCK bt instr*) is valid with the function type t_1* -> t_2* if: |
| - the block type bt is valid with t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_2*]. |
| - Under the context C', the instruction sequence instr* is valid with t_1* -> t_2*. |
| |
| Instr_ok/loop |
| - the instruction (LOOP bt instr*) is valid with the function type t_1* -> t_2* if: |
| - the block type bt is valid with t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_1*]. |
| - Under the context C', the instruction sequence instr* is valid with t_1* -> t_2*. |
| |
| Instr_ok/if |
| - the instruction (IF bt instr_1* ELSE instr_2*) is valid with the function type t_1* :: [I32] -> t_2* if: |
| - the block type bt is valid with the function type t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_2*]. |
| - Under the context C', the instruction sequence instr_1* is valid with t_1* -> t_2*. |
| - Under the context C', the instruction sequence instr_2* is valid with t_1* -> t_2*. |
| |
| Instr_ok/br |
| - the instruction (BR l) is valid with the function type t_1* :: t* -> t_2* if: |
| - the result type C.LABELS[l] exists. |
| - C.LABELS[l] is t*. |
| |
| Instr_ok/br_if |
| - the instruction (BR_IF l) is valid with the function type t* :: [I32] -> t* if: |
| - the result type C.LABELS[l] exists. |
| - C.LABELS[l] is t*. |
| |
| Instr_ok/br_table |
| - the instruction (BR_TABLE l* l') is valid with the function type t_1* :: t* :: [I32] -> t_2* if: |
| - For all l in l*: |
| - the result type C.LABELS[l] exists. |
| - the result type t* matches C.LABELS[l]. |
| - the result type C.LABELS[l'] exists. |
| - t* matches C.LABELS[l']. |
| |
| Instr_ok/call |
| - the instruction (CALL x) is valid with the function type t_1* -> t_2* if: |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is t_1* -> t_2*. |
| |
| Instr_ok/call_indirect |
| - the instruction (CALL_INDIRECT x y) is valid with the function type t_1* :: [I32] -> t_2* if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim FUNCREF). |
| - the function type C.TYPES[y] exists. |
| - C.TYPES[y] is t_1* -> t_2*. |
| |
| Instr_ok/return |
| - the instruction RETURN is valid with the function type t_1* :: t* -> t_2* if: |
| - the result type C.RETURN is ?(t*). |
| |
| Instr_ok/const |
| - the instruction (nt.CONST c_nt) is valid with the function type [] -> [nt]. |
| |
| Instr_ok/unop |
| - the instruction (UNOP nt unop_nt) is valid with the function type [nt] -> [nt]. |
| |
| Instr_ok/binop |
| - the instruction (BINOP nt binop_nt) is valid with the function type [nt, nt] -> [nt]. |
| |
| Instr_ok/testop |
| - the instruction (TESTOP nt testop_nt) is valid with the function type [nt] -> [I32]. |
| |
| Instr_ok/relop |
| - the instruction (RELOP nt relop_nt) is valid with the function type [nt, nt] -> [I32]. |
| |
| Instr_ok/cvtop |
| - the instruction (CVTOP nt_1 nt_2 cvtop) is valid with the function type [nt_2] -> [nt_1] if: |
| - Either: |
| - cvtop is REINTERPRET. |
| - $size(nt_1) is $size(nt_2). |
| - Or: |
| |
| |
| Instr_ok/ref.null |
| - the instruction (REF.NULL rt) is valid with the function type [] -> [rt]. |
| |
| Instr_ok/ref.func |
| - the instruction (REF.FUNC x) is valid with the function type [] -> [FUNCREF] if: |
| - the function type C.FUNCS[x] exists. |
| |
| Instr_ok/ref.is_null |
| - the instruction REF.IS_NULL is valid with the function type [rt] -> [I32]. |
| |
| Instr_ok/vconst |
| - the instruction (V128.CONST c) is valid with the function type [] -> [V128]. |
| |
| Instr_ok/vvunop |
| - the instruction (VVUNOP V128 vvunop) is valid with the function type [V128] -> [V128]. |
| |
| Instr_ok/vvbinop |
| - the instruction (VVBINOP V128 vvbinop) is valid with the function type [V128, V128] -> [V128]. |
| |
| Instr_ok/vvternop |
| - the instruction (VVTERNOP V128 vvternop) is valid with the function type [V128, V128, V128] -> [V128]. |
| |
| Instr_ok/vvtestop |
| - the instruction (VVTESTOP V128 vvtestop) is valid with the function type [V128] -> [I32]. |
| |
| Instr_ok/vunop |
| - the instruction (VUNOP sh vunop_sh) is valid with [V128] -> [V128]. |
| |
| Instr_ok/vbinop |
| - the instruction (VBINOP sh vbinop_sh) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vtestop |
| - the instruction (VTESTOP sh vtestop_sh) is valid with [V128] -> [I32]. |
| |
| Instr_ok/vrelop |
| - the instruction (VRELOP sh vrelop_sh) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vshiftop |
| - the instruction (VSHIFTOP sh vshiftop_sh) is valid with the function type [V128, I32] -> [V128]. |
| |
| Instr_ok/vbitmask |
| - the instruction (VBITMASK sh) is valid with [V128] -> [I32]. |
| |
| Instr_ok/vswizzle |
| - the instruction (VSWIZZLE sh) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vshuffle |
| - the instruction (VSHUFFLE sh i*) is valid with the function type [V128, V128] -> [V128] if: |
| - For all i in i*: |
| - the lane index i is less than (2 * $dim(sh)). |
| |
| Instr_ok/vsplat |
| - the instruction (VSPLAT sh) is valid with the function type [numtype] -> [V128] if: |
| - the number type numtype is $shunpack(sh). |
| |
| Instr_ok/vextract_lane |
| - the instruction (VEXTRACT_LANE sh sx? i) is valid with the function type [V128] -> [numtype] if: |
| - the lane index i is less than $dim(sh). |
| - the number type numtype is $shunpack(sh). |
| |
| Instr_ok/vreplace_lane |
| - the instruction (VREPLACE_LANE sh i) is valid with the function type [V128, numtype] -> [V128] if: |
| - the lane index i is less than $dim(sh). |
| - the number type numtype is $shunpack(sh). |
| |
| Instr_ok/vextunop |
| - the instruction (VEXTUNOP sh_1 sh_2 vextunop) is valid with the function type [V128] -> [V128]. |
| |
| Instr_ok/vextbinop |
| - the instruction (VEXTBINOP sh_1 sh_2 vextbinop) is valid with the function type [V128, V128] -> [V128]. |
| |
| Instr_ok/vnarrow |
| - the instruction (VNARROW sh_1 sh_2 sx) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vcvtop |
| - the instruction (VCVTOP sh_1 sh_2 vcvtop) is valid with [V128] -> [V128]. |
| |
| Instr_ok/local.get |
| - the instruction (LOCAL.GET x) is valid with the function type [] -> [t] if: |
| - the value type C.LOCALS[x] exists. |
| - C.LOCALS[x] is t. |
| |
| Instr_ok/local.set |
| - the instruction (LOCAL.SET x) is valid with the function type [t] -> [] if: |
| - the value type C.LOCALS[x] exists. |
| - C.LOCALS[x] is t. |
| |
| Instr_ok/local.tee |
| - the instruction (LOCAL.TEE x) is valid with the function type [t] -> [t] if: |
| - the value type C.LOCALS[x] exists. |
| - C.LOCALS[x] is t. |
| |
| Instr_ok/global.get |
| - the instruction (GLOBAL.GET x) is valid with the function type [] -> [t] if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (mut t). |
| |
| Instr_ok/global.set |
| - the instruction (GLOBAL.SET x) is valid with the function type [t] -> [] if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?(MUT) t). |
| |
| Instr_ok/table.get |
| - the instruction (TABLE.GET x) is valid with the function type [I32] -> [rt] if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim rt). |
| |
| Instr_ok/table.set |
| - the instruction (TABLE.SET x) is valid with the function type [I32, rt] -> [] if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim rt). |
| |
| Instr_ok/table.size |
| - the instruction (TABLE.SIZE x) is valid with the function type [] -> [I32] if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim rt). |
| |
| Instr_ok/table.grow |
| - the instruction (TABLE.GROW x) is valid with the function type [rt, I32] -> [I32] if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim rt). |
| |
| Instr_ok/table.fill |
| - the instruction (TABLE.FILL x) is valid with the function type [I32, rt, I32] -> [] if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim rt). |
| |
| Instr_ok/table.copy |
| - the instruction (TABLE.COPY x_1 x_2) is valid with the function type [I32, I32, I32] -> [] if: |
| - the table type C.TABLES[x_1] exists. |
| - C.TABLES[x_1] is (lim_1 rt). |
| - the table type C.TABLES[x_2] exists. |
| - C.TABLES[x_2] is (lim_2 rt). |
| |
| Instr_ok/table.init |
| - the instruction (TABLE.INIT x_1 x_2) is valid with the function type [I32, I32, I32] -> [] if: |
| - the table type C.TABLES[x_1] exists. |
| - C.TABLES[x_1] is (lim rt). |
| - the element type C.ELEMS[x_2] exists. |
| - C.ELEMS[x_2] is rt. |
| |
| Instr_ok/elem.drop |
| - the instruction (ELEM.DROP x) is valid with the function type [] -> [] if: |
| - the element type C.ELEMS[x] exists. |
| |
| Instr_ok/memory.size |
| - the instruction MEMORY.SIZE is valid with the function type [] -> [I32]. |
| |
| Instr_ok/memory.grow |
| - the instruction MEMORY.GROW is valid with the function type [I32] -> [I32]. |
| |
| Instr_ok/memory.fill |
| - the instruction MEMORY.FILL is valid with the function type [I32, I32, I32] -> []. |
| |
| Instr_ok/memory.copy |
| - the instruction MEMORY.COPY is valid with [I32, I32, I32] -> []. |
| |
| Instr_ok/memory.init |
| - the instruction (MEMORY.INIT x) is valid with the function type [I32, I32, I32] -> [] if: |
| - the data type C.DATAS[x] exists. |
| - C.DATAS[x] is OK. |
| |
| Instr_ok/data.drop |
| - the instruction (DATA.DROP x) is valid with the function type [] -> [] if: |
| - the data type C.DATAS[x] exists. |
| - C.DATAS[x] is OK. |
| |
| Instr_ok/load |
| - the instruction (LOAD nt loadop_? memarg) is valid with the function type [I32] -> [valtype] if: |
| - Either: |
| - loadop_? is ?(). |
| - the value type valtype is nt. |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(nt) / 8). |
| - Or: |
| - the number type nt is Inn. |
| - loadop_? is ?(M _ sx). |
| - valtype is Inn. |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instr_ok/store |
| - the instruction (STORE nt sz? memarg) is valid with the function type [I32, valtype] -> [] if: |
| - Either: |
| - the pack size sz? is ?(). |
| - the value type valtype is nt. |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(nt) / 8). |
| - Or: |
| - the number type nt is Inn. |
| - sz? is ?(M). |
| - valtype is Inn. |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instr_ok/vload |
| - the instruction (VLOAD V128 ?(vloadop) memarg) is valid with the function type [I32] -> [V128] if: |
| - Either: |
| - vloadop is (SHAPE M X N _ sx). |
| - (2 ^ memarg.ALIGN) is less than or equal to ((M / 8) * N). |
| - Or: |
| - vloadop is (SPLAT n). |
| - (2 ^ memarg.ALIGN) is less than or equal to (n / 8). |
| - Or: |
| - vloadop is (ZERO n). |
| - (2 ^ memarg.ALIGN) is less than or equal to (n / 8). |
| |
| Instr_ok/vload_lane |
| - the instruction (VLOAD_LANE V128 n memarg laneidx) is valid with the function type [I32, V128] -> [V128] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (n / 8). |
| - laneidx is less than (128 / n). |
| |
| Instr_ok/vstore |
| - the instruction (VSTORE V128 memarg) is valid with the function type [I32, V128] -> [] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(V128) / 8). |
| |
| Instr_ok/vstore_lane |
| - the instruction (VSTORE_LANE V128 n memarg laneidx) is valid with the function type [I32, V128] -> [] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (n / 8). |
| - laneidx is less than (128 / n). |
| |
| Instr_ok/select-expl |
| - the instruction (SELECT ?([t])) is valid with the function type [t, t, I32] -> [t]. |
| |
| Instr_ok/select-impl |
| - the instruction (SELECT ?()) is valid with the function type [t, t, I32] -> [t] if: |
| - the value type t matches the value type t'. |
| - t' is numtype or t' is vectype. |
| |
| Instr_ok/cvtop-reinterpret |
| - the instruction (CVTOP nt_1 nt_2 REINTERPRET) is valid with the function type [nt_2] -> [nt_1] if: |
| - $size(nt_1) is $size(nt_2). |
| |
| Instr_ok/cvtop-convert |
| - the instruction (CVTOP nt_1 nt_2 cvtop) is valid with [nt_2] -> [nt_1]. |
| |
| Instr_ok/load-val |
| - the instruction (LOAD nt ?() memarg) is valid with the function type [I32] -> [nt] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(nt) / 8). |
| |
| Instr_ok/load-pack |
| - the instruction (LOAD Inn ?(M _ sx) memarg) is valid with the function type [I32] -> [Inn] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instr_ok/store-val |
| - the instruction (STORE nt ?() memarg) is valid with the function type [I32, nt] -> [] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to ($size(nt) / 8). |
| |
| Instr_ok/store-pack |
| - the instruction (STORE Inn ?(M) memarg) is valid with the function type [I32, Inn] -> [] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (M / 8). |
| |
| Instr_ok/vload |
| - the instruction (VLOAD V128 ?((SHAPE M X N _ sx)) memarg) is valid with the function type [I32] -> [V128] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to ((M / 8) * N). |
| |
| Instr_ok/vload-splat |
| - the instruction (VLOAD V128 ?((SPLAT n)) memarg) is valid with the function type [I32] -> [V128] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (n / 8). |
| |
| Instr_ok/vload-zero |
| - the instruction (VLOAD V128 ?((ZERO n)) memarg) is valid with the function type [I32] -> [V128] if: |
| - (2 ^ memarg.ALIGN) is less than or equal to (n / 8). |
| |
| Instrs_ok |
| - the instruction sequence instr* is valid with the function type valtype* -> valtype'* if: |
| - Either: |
| - instr* is []. |
| - the value type sequence valtype* is []. |
| - the value type sequence valtype'* is []. |
| - Or: |
| - instr* is [instr_1] :: instr_2*. |
| - the instruction instr_1 is valid with the function type valtype* -> t_2*. |
| - the instruction sequence instr_2* is valid with the function type t_2* -> valtype'*. |
| - Or: |
| - instr* is valid with the function type t_1* -> t_2*. |
| - valtype* matches the result type t_1*. |
| - the result type t_2* matches valtype'*. |
| - Or: |
| - valtype* is t* :: t_1*. |
| - valtype'* is t* :: t_2*. |
| - instr* is valid with t_1* -> t_2*. |
| |
| Instrs_ok/empty |
| - the instruction sequence [] is valid with the function type [] -> []. |
| |
| Instrs_ok/seq |
| - the instruction sequence [instr_1] :: instr_2* is valid with the function type t_1* -> t_3* if: |
| - the instruction instr_1 is valid with the function type t_1* -> t_2*. |
| - the instruction sequence instr_2* is valid with the function type t_2* -> t_3*. |
| |
| Instrs_ok/sub |
| - the instruction sequence instr* is valid with the function type t'_1* -> t'_2* if: |
| - instr* is valid with the function type t_1* -> t_2*. |
| - the result type t'_1* matches the result type t_1*. |
| - the result type t_2* matches the result type t'_2*. |
| |
| Instrs_ok/frame |
| - the instruction sequence instr* is valid with the function type t* :: t_1* -> t* :: t_2* if: |
| - instr* is valid with the function type t_1* -> t_2*. |
| |
| Expr_ok |
| - the expression instr* is valid with the result type t* if: |
| - instr* is valid with the function type [] -> t*. |
| |
| Instr_const |
| - the instruction instr is constant if: |
| - Either: |
| - instr is (nt.CONST c). |
| - Or: |
| - instr is (vt.CONST vc). |
| - Or: |
| - instr is (REF.NULL rt). |
| - Or: |
| - instr is (REF.FUNC x). |
| - Or: |
| - instr is (GLOBAL.GET x). |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?() t). |
| |
| Instr_const/const |
| - the instruction (nt.CONST c) is constant. |
| |
| Instr_const/vconst |
| - the instruction (vt.CONST vc) is constant. |
| |
| Instr_const/ref.null |
| - the instruction (REF.NULL rt) is constant. |
| |
| Instr_const/ref.func |
| - the instruction (REF.FUNC x) is constant. |
| |
| Instr_const/global.get |
| - the instruction (GLOBAL.GET x) is constant if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?() t). |
| |
| Expr_const |
| - the expression instr* is constant if: |
| - For all instr in instr*: |
| - the instruction instr is constant. |
| |
| Type_ok |
| - the type (TYPE ft) is valid with the function type ft if: |
| - ft is valid. |
| |
| Func_ok |
| - the function (FUNC x (LOCAL t)* expr) is valid with the function type t_1* -> t_2* if: |
| - the function type C.TYPES[x] exists. |
| - C.TYPES[x] is t_1* -> t_2*. |
| - For all t in t*: |
| - the value type t is not BOT. |
| - Under the context C with .LOCALS appended by t_1* :: t* and .LABELS appended by [t_2*] and .RETURN appended by ?(t_2*), the expression expr is valid with the result type t_2*. |
| |
| Global_ok |
| - the global (GLOBAL gt expr) is valid with the global type gt if: |
| - gt is valid. |
| - gt is (mut t). |
| - the expression expr is valid with the value type t. |
| - expr is constant. |
| |
| Table_ok |
| - the table (TABLE tt) is valid with the table type tt if: |
| - tt is valid. |
| |
| Mem_ok |
| - the memory (MEMORY mt) is valid with the memory type mt if: |
| - mt is valid. |
| |
| Elemmode_ok |
| - elemmode is valid with the reference type rt if: |
| - Either: |
| - elemmode is (ACTIVE x expr). |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim rt). |
| - the expression expr is valid with the value type I32. |
| - expr is constant. |
| - Or: |
| - elemmode is PASSIVE. |
| - Or: |
| - elemmode is DECLARE. |
| |
| Elemmode_ok/active |
| - (ACTIVE x expr) is valid with the reference type rt if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is (lim rt). |
| - the expression expr is valid with the value type I32. |
| - expr is constant. |
| |
| Elemmode_ok/passive |
| - PASSIVE is valid with rt. |
| |
| Elemmode_ok/declare |
| - DECLARE is valid with rt. |
| |
| Elem_ok |
| - the table segment (ELEM rt expr* elemmode) is valid with the reference type rt if: |
| - For all expr in expr*: |
| - the expression expr is valid with rt. |
| - expr is constant. |
| - elemmode is valid with rt. |
| |
| Datamode_ok |
| - datamode is valid if: |
| - Either: |
| - datamode is (ACTIVE 0 expr). |
| - the expression expr is valid with the value type I32. |
| - expr is constant. |
| - Or: |
| - datamode is PASSIVE. |
| |
| Datamode_ok/active |
| - (ACTIVE 0 expr) is valid if: |
| - the expression expr is valid with the value type I32. |
| - expr is constant. |
| |
| Datamode_ok/passive |
| - PASSIVE is always valid. |
| |
| Data_ok |
| - the memory segment (DATA b* datamode) is valid if: |
| - datamode is valid. |
| |
| Start_ok |
| - the start function (START x) is valid if: |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is [] -> []. |
| |
| Import_ok |
| - the import (IMPORT name_1 name_2 xt) is valid with the external type xt if: |
| - xt is valid. |
| |
| Externidx_ok |
| - the external index externidx is valid with the external type externtype if: |
| - Either: |
| - externidx is (FUNC x). |
| - externtype is (FUNC ft). |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is ft. |
| - Or: |
| - externidx is (GLOBAL x). |
| - externtype is (GLOBAL gt). |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is gt. |
| - Or: |
| - externidx is (TABLE x). |
| - externtype is (TABLE tt). |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is tt. |
| - Or: |
| - externidx is (MEM x). |
| - externtype is (MEM mt). |
| - the memory type C.MEMS[x] exists. |
| - C.MEMS[x] is mt. |
| |
| Externidx_ok/func |
| - the external index (FUNC x) is valid with the external type (FUNC ft) if: |
| - the function type C.FUNCS[x] exists. |
| - C.FUNCS[x] is ft. |
| |
| Externidx_ok/global |
| - the external index (GLOBAL x) is valid with the external type (GLOBAL gt) if: |
| - the global type C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is gt. |
| |
| Externidx_ok/table |
| - the external index (TABLE x) is valid with the external type (TABLE tt) if: |
| - the table type C.TABLES[x] exists. |
| - C.TABLES[x] is tt. |
| |
| Externidx_ok/mem |
| - the external index (MEM x) is valid with the external type (MEM mt) if: |
| - the memory type C.MEMS[x] exists. |
| - C.MEMS[x] is mt. |
| |
| Export_ok |
| - the export (EXPORT name externidx) is valid with the external type xt if: |
| - the external index externidx is valid with xt. |
| |
| Module_ok |
| - the module (MODULE type* import* func* global* table* mem* elem* data^n start? export*) is valid if: |
| - For all type in type*: |
| - the type type is valid with the function type ft'. |
| - ft'* is the concatenation of all such ft'. |
| - For all import in import*: |
| - Under the context { TYPES: ft'*; RETURN: ?() }, the import import is valid with the external type ixt. |
| - ixt* is the concatenation of all such ixt. |
| - For all global in global*: |
| - Under the context C', the global global is valid with the global type gt. |
| - gt* is the concatenation of all such gt. |
| - For all table in table*: |
| - Under the context C', the table table is valid with the table type tt. |
| - tt* is the concatenation of all such tt. |
| - For all mem in mem*: |
| - Under the context C', the memory mem is valid with the memory type mt. |
| - mt* is the concatenation of all such mt. |
| - For all elem in elem*: |
| - Under the context C', the table segment elem is valid with the reference type rt. |
| - rt* is the concatenation of all such rt. |
| - For all data in data*: |
| - Under the context C', the memory segment data is valid. |
| - For all func in func*: |
| - the function func is valid with the function type ft. |
| - ft* is the concatenation of all such ft. |
| - If start is defined, then: |
| - the start function start is valid. |
| - For all export in export*: |
| - the export export is valid with the external type xt. |
| - |mt*| is less than or equal to 1. |
| - the context C' is { TYPES: ft'*; FUNCS: ift* :: ft*; GLOBALS: igt*; TABLES: itt* :: tt*; MEMS: imt* :: mt*; RETURN: ?() }. |
| - the function type sequence ift* is $funcsxt(ixt*). |
| - the global type sequence igt* is $globalsxt(ixt*). |
| - the table type sequence itt* is $tablesxt(ixt*). |
| - the memory type sequence imt* is $memsxt(ixt*). |
| |
| Step_read/table.copy-trap-* x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$table(z, y).REFS|), then: |
| a. Trap. |
| 9. If ((j + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| |
| Step_read/table.init-trap-* x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$elem(z, y).REFS|), then: |
| a. Trap. |
| 9. If ((j + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| |
| Step_read/load-num-* nt ?() ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 5. Let c be $nbytes__1^-1(nt, $mem(z, 0).BYTES[(i + ao.OFFSET) : ($size(nt) / 8)]). |
| 6. Push the value (nt.CONST c) to the stack. |
| |
| Step_read/load-pack-* Inn ?(n _ sx) ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 5. Let c be $ibytes__1^-1(n, $mem(z, 0).BYTES[(i + ao.OFFSET) : (n / 8)]). |
| 6. Push the value (Inn.CONST $extend__(n, $size(Inn), sx, c)) to the stack. |
| |
| Step_read/vload-shape-* V128 ?((SHAPE M X N _ sx)) ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + ((M * N) / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 5. Let j^N be $ibytes__1^-1(M, $mem(z, 0).BYTES[((i + ao.OFFSET) + ((k * M) / 8)) : (M / 8)])^(k<N). |
| 6. Let Jnn be $jsize^-1((M * 2)). |
| 7. Let c be $inv_lanes_(Jnn X N, $extend__(M, $jsize(Jnn), sx, j)^N). |
| 8. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/vload-splat-* V128 ?((SPLAT N)) ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 5. Let M be (128 / N). |
| 6. Let Jnn be $jsize^-1(N). |
| 7. Let j be $ibytes__1^-1(N, $mem(z, 0).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 8. Let c be $inv_lanes_(Jnn X M, j^M). |
| 9. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/vload-zero-* V128 ?((ZERO N)) ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 5. Let j be $ibytes__1^-1(N, $mem(z, 0).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 6. Let c be $extend__(N, 128, U, j). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/memory.copy-trap-* |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 9. If ((j + n) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| |
| Step_read/memory.init-trap-* x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$data(z, x).BYTES|), then: |
| a. Trap. |
| 9. If ((j + n) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| |
| Step/store-num-* nt ?() ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 3. Pop the value (numtype_0.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $nbytes_(nt, c). |
| 8. Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(nt) / 8), b*). |
| |
| Step/store-pack-* Inn ?(n) ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type Inn is on the top of the stack. |
| 3. Pop the value (numtype_0.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)). |
| 8. Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*). |
| |
| Step_pure/unreachable |
| 1. Trap. |
| |
| Step_pure/nop |
| 1. Do nothing. |
| |
| Step_pure/drop |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| |
| Step_pure/select t*? |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. Assert: Due to validation, a value is on the top of the stack. |
| 4. Pop the value val_2 from the stack. |
| 5. Assert: Due to validation, a value is on the top of the stack. |
| 6. Pop the value val_1 from the stack. |
| 7. If (c =/= 0), then: |
| a. Push the value val_1 to the stack. |
| 8. Else: |
| a. Push the value val_2 to the stack. |
| |
| Step_pure/if bt instr_1* instr_2* |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. If (c =/= 0), then: |
| a. Execute the instruction (BLOCK bt instr_1*). |
| 4. Else: |
| a. Execute the instruction (BLOCK bt instr_2*). |
| |
| Step_pure/label |
| 1. Pop all values val* from the top of the stack. |
| 2. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| 3. Pop the label (LABEL_ _ { _ }) from the stack. |
| 4. Push the values val* to the stack. |
| |
| Step_pure/br n' |
| 1. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| 2. Let (LABEL_ n { instr'* }) be the topmost LABEL_. |
| 3. If (n' = 0), then: |
| a. Assert: Due to validation, there are at least n values on the top of the stack. |
| b. Pop the values val^n from the stack. |
| c. Pop all values val'* from the top of the stack. |
| d. Pop the label (LABEL_ _ { _ }) from the stack. |
| e. Push the values val^n to the stack. |
| f. Execute the sequence instr'*. |
| 4. Else: |
| a. Pop all values val* from the top of the stack. |
| b. Let l be (n' - 1). |
| c. Pop the label (LABEL_ _ { _ }) from the stack. |
| d. Push the values val* to the stack. |
| e. Execute the instruction (BR l). |
| |
| Step_pure/br_if l |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. If (c =/= 0), then: |
| a. Execute the instruction (BR l). |
| 4. Else: |
| a. Do nothing. |
| |
| Step_pure/br_table l* l' |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST i) from the stack. |
| 3. If (i < |l*|), then: |
| a. Execute the instruction (BR l*[i]). |
| 4. Else: |
| a. Execute the instruction (BR l'). |
| |
| Step_pure/frame |
| 1. Let (FRAME_ n { f }) be the topmost FRAME_. |
| 2. Assert: Due to validation, there are at least n values on the top of the stack. |
| 3. Assert: Due to validation, there are at least n values on the top of the stack. |
| 4. Pop the values val^n from the stack. |
| 5. Assert: Due to validation, the first non-value entry of the stack is a FRAME_. |
| 6. Pop the frame (FRAME_ _ { _ }) from the stack. |
| 7. Push the values val^n to the stack. |
| |
| Step_pure/return |
| 1. If the first non-value entry of the stack is a FRAME_, then: |
| a. Let (FRAME_ n { f }) be the topmost FRAME_. |
| b. Assert: Due to validation, there are at least n values on the top of the stack. |
| c. Pop the values val^n from the stack. |
| d. Pop all values val'* from the top of the stack. |
| e. Pop the frame (FRAME_ _ { _ }) from the stack. |
| f. Push the values val^n to the stack. |
| 2. Else: |
| a. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| b. Pop all values val* from the top of the stack. |
| c. Pop the label (LABEL_ _ { _ }) from the stack. |
| d. Push the values val* to the stack. |
| e. Execute the instruction RETURN. |
| |
| Step_pure/unop nt unop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. If (|$unop_(nt, unop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $unop_(nt, unop, c_1). |
| 5. Push the value (nt.CONST c) to the stack. |
| |
| Step_pure/binop nt binop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 4. Pop the value (numtype_0.CONST c_1) from the stack. |
| 5. If (|$binop_(nt, binop, c_1, c_2)| <= 0), then: |
| a. Trap. |
| 6. Let c be an element of $binop_(nt, binop, c_1, c_2). |
| 7. Push the value (nt.CONST c) to the stack. |
| |
| Step_pure/testop nt testop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. Let c be $testop_(nt, testop, c_1). |
| 4. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/relop nt relop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 4. Pop the value (numtype_0.CONST c_1) from the stack. |
| 5. Let c be $relop_(nt, relop, c_1, c_2). |
| 6. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/cvtop nt_2 nt_1 cvtop |
| 1. Assert: Due to validation, a value of value type nt_1 is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. If (|$cvtop__(nt_1, nt_2, cvtop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $cvtop__(nt_1, nt_2, cvtop, c_1). |
| 5. Push the value (nt_2.CONST c) to the stack. |
| |
| Step_pure/ref.is_null |
| 1. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 2. Pop the value ref from the stack. |
| 3. If ref is some REF.NULL, then: |
| a. Push the value (I32.CONST 1) to the stack. |
| 4. Else: |
| a. Push the value (I32.CONST 0) to the stack. |
| |
| Step_pure/vvunop V128 vvunop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let c be $vvunop_(V128, vvunop, c_1). |
| 4. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vvbinop V128 vvbinop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vvbinop_(V128, vvbinop, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vvternop V128 vvternop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_3) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_2) from the stack. |
| 5. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 6. Pop the value (V128.CONST c_1) from the stack. |
| 7. Let c be $vvternop_(V128, vvternop, c_1, c_2, c_3). |
| 8. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vvtestop V128 ANY_TRUE |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let c be $ine_($size(V128), c_1, 0). |
| 4. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/vunop sh vunop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. If (|$vunop_(sh, vunop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $vunop_(sh, vunop, c_1). |
| 5. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vbinop sh vbinop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. If (|$vbinop_(sh, vbinop, c_1, c_2)| <= 0), then: |
| a. Trap. |
| 6. Let c be an element of $vbinop_(sh, vbinop, c_1, c_2). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vtestop Jnn X N ALL_TRUE |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c) from the stack. |
| 3. Let ci_1* be $lanes_(Jnn X N, c). |
| 4. If (ci_1 =/= 0)*, then: |
| a. Push the value (I32.CONST 1) to the stack. |
| 5. Else: |
| a. Push the value (I32.CONST 0) to the stack. |
| |
| Step_pure/vrelop sh vrelop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vrelop_(sh, vrelop, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vshiftop Jnn X N vshiftop |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST n) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c'* be $lanes_(Jnn X N, c_1). |
| 6. Let c be $inv_lanes_(Jnn X N, $vshiftop_(Jnn X N, vshiftop, c', n)*). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vbitmask Jnn X N |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c) from the stack. |
| 3. Let ci_1* be $lanes_(Jnn X N, c). |
| 4. Let ci be $ibits__1^-1(32, $ilt_($lsize(Jnn), S, ci_1, 0)* :: 0^(32 - N)). |
| 5. Push the value (I32.CONST $irev_(32, ci)) to the stack. |
| |
| Step_pure/vswizzle Pnn X M |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c'* be $lanes_(Pnn X M, c_1) :: 0^(256 - M). |
| 6. Let ci* be $lanes_(Pnn X M, c_2). |
| 7. Assert: Due to validation, (ci*[k] < |c'*|)^(k<M). |
| 8. Assert: Due to validation, (k < |ci*|)^(k<M). |
| 9. Let c be $inv_lanes_(Pnn X M, c'*[ci*[k]]^(k<M)). |
| 10. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vshuffle Pnn X N i* |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Assert: Due to validation, (k < |i*|)^(k<N). |
| 6. Let c'* be $lanes_(Pnn X N, c_1) :: $lanes_(Pnn X N, c_2). |
| 7. Assert: Due to validation, (i*[k] < |c'*|)^(k<N). |
| 8. Let c be $inv_lanes_(Pnn X N, c'*[i*[k]]^(k<N)). |
| 9. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vsplat Lnn X N |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. Assert: Due to validation, (numtype_0 = $unpack(Lnn)). |
| 4. Let c be $inv_lanes_(Lnn X N, $packnum_(Lnn, c_1)^N). |
| 5. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vextract_lane lanetype X N sx'? i |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. If sx'? is not defined, then: |
| a. Assert: Due to validation, lanetype is numtype. |
| b. Assert: Due to validation, (i < |$lanes_(lanetype X N, c_1)|). |
| c. Let c_2 be $lanes_(lanetype X N, c_1)[i]. |
| d. Push the value (lanetype.CONST c_2) to the stack. |
| 4. Else: |
| a. Assert: Due to validation, lanetype is packtype. |
| b. Let ?(sx) be sx'?. |
| c. Assert: Due to validation, (i < |$lanes_(lanetype X N, c_1)|). |
| d. Let c_2 be $extend__($psize(lanetype), 32, sx, $lanes_(lanetype X N, c_1)[i]). |
| e. Push the value (I32.CONST c_2) to the stack. |
| |
| Step_pure/vreplace_lane Lnn X N i |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, (numtype_0 = $unpack(Lnn)). |
| 4. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 5. Pop the value (V128.CONST c_1) from the stack. |
| 6. Let c be $inv_lanes_(Lnn X N, $lanes_(Lnn X N, c_1) with [i] replaced by $packnum_(Lnn, c_2)). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vextunop sh_1 sh_2 vextunop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let c be $vextunop__(sh_1, sh_2, vextunop, c_1). |
| 4. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vextbinop sh_1 sh_2 vextbinop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vextbinop__(sh_1, sh_2, vextbinop, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vnarrow Jnn_2 X N_2 Jnn_1 X N_1 sx |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let ci_1* be $lanes_(Jnn_1 X N_1, c_1). |
| 6. Let ci_2* be $lanes_(Jnn_1 X N_1, c_2). |
| 7. Let cj_1* be []. |
| 8. For each ci_1 in ci_1*, do: |
| a. Let cj_1 be $narrow__($lsize(Jnn_1), $lsize(Jnn_2), sx, ci_1). |
| b. Append cj_1 to the cj_1*. |
| 9. Let cj_2* be []. |
| 10. For each ci_2 in ci_2*, do: |
| a. Let cj_2 be $narrow__($lsize(Jnn_1), $lsize(Jnn_2), sx, ci_2). |
| b. Append cj_2 to the cj_2*. |
| 11. Let c be $inv_lanes_(Jnn_2 X N_2, cj_1* :: cj_2*). |
| 12. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vcvtop Lnn_2 X M Lnn_1 X M' vcvtop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. If $halfop(vcvtop) is defined, then: |
| a. Let ?(half) be $halfop(vcvtop). |
| b. Let ci* be $lanes_(Lnn_1 X M', c_1)[$half(half, 0, M) : M]. |
| c. Let cj** be $setproduct_(`lane_(Lnn_2), $vcvtop__(Lnn_1 X M', Lnn_2 X M, vcvtop, ci)*). |
| d. If (|$inv_lanes_(Lnn_2 X M, cj*)*| > 0), then: |
| 1) Let c be an element of $inv_lanes_(Lnn_2 X M, cj*)*. |
| 2) Push the value (V128.CONST c) to the stack. |
| 4. Else if ($zeroop(vcvtop) is not defined /\ (M = M')), then: |
| a. Let ci* be $lanes_(Lnn_1 X M', c_1). |
| b. Let cj** be $setproduct_(`lane_(Lnn_2), $vcvtop__(Lnn_1 X M', Lnn_2 X M', vcvtop, ci)*). |
| c. If (|$inv_lanes_(Lnn_2 X M', cj*)*| > 0), then: |
| 1) Let c be an element of $inv_lanes_(Lnn_2 X M', cj*)*. |
| 2) Push the value (V128.CONST c) to the stack. |
| 5. If (($zeroop(vcvtop) = ?(ZERO)) /\ (Lnn_1 is numtype /\ Lnn_2 is numtype)), then: |
| a. Let ci* be $lanes_(Lnn_1 X M', c_1). |
| b. Let cj** be $setproduct_(`lane_((nt_2 : numtype <: lanetype)), $vcvtop__(Lnn_1 X M', Lnn_2 X M, vcvtop, ci)* :: [$zero(Lnn_2)]^M'). |
| c. If (|$inv_lanes_(Lnn_2 X M, cj*)*| > 0), then: |
| 1) Let c be an element of $inv_lanes_(Lnn_2 X M, cj*)*. |
| 2) Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/local.tee x |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| 3. Push the value val to the stack. |
| 4. Push the value val to the stack. |
| 5. Execute the instruction (LOCAL.SET x). |
| |
| Step_read/block bt instr* |
| 1. Let z be the current state. |
| 2. Let t_1^k -> t_2^n be $blocktype(z, bt). |
| 3. Assert: Due to validation, there are at least k values on the top of the stack. |
| 4. Pop the values val^k from the stack. |
| 5. Enter val^k :: instr* with label (LABEL_ n { [] }). |
| |
| Step_read/loop bt instr* |
| 1. Let z be the current state. |
| 2. Let t_1^k -> t_2^n be $blocktype(z, bt). |
| 3. Assert: Due to validation, there are at least k values on the top of the stack. |
| 4. Pop the values val^k from the stack. |
| 5. Enter val^k :: instr* with label (LABEL_ k { [(LOOP bt instr*)] }). |
| |
| Step_read/call x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (x < |$funcaddr(z)|). |
| 3. Execute the instruction (CALL_ADDR $funcaddr(z)[x]). |
| |
| Step_read/call_indirect x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (i >= |$table(z, x).REFS|), then: |
| a. Trap. |
| 5. If $table(z, x).REFS[i] is not REF.FUNC_ADDR, then: |
| a. Trap. |
| 6. Let (REF.FUNC_ADDR a) be $table(z, x).REFS[i]. |
| 7. If (a >= |$funcinst(z)|), then: |
| a. Trap. |
| 8. If ($type(z, y) =/= $funcinst(z)[a].TYPE), then: |
| a. Trap. |
| 9. Execute the instruction (CALL_ADDR a). |
| |
| Step_read/call_addr a |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (a < |$funcinst(z)|). |
| 3. Let { TYPE: t_1^k -> t_2^n; MODULE: mm; CODE: func } be $funcinst(z)[a]. |
| 4. Let (FUNC x local_0* instr*) be func. |
| 5. Let t* be []. |
| 6. For each local_0 in local_0*, do: |
| a. Let (LOCAL t) be local_0. |
| b. Append t to the t*. |
| 7. Assert: Due to validation, there are at least k values on the top of the stack. |
| 8. Pop the values val^k from the stack. |
| 9. Let f be { LOCALS: val^k :: $default_(t)*; MODULE: mm }. |
| 10. Push the frame (FRAME_ n { f }) to the stack. |
| 11. Enter instr* with label (LABEL_ n { [] }). |
| |
| Step_read/ref.func x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (x < |$funcaddr(z)|). |
| 3. Push the value (REF.FUNC_ADDR $funcaddr(z)[x]) to the stack. |
| |
| Step_read/local.get x |
| 1. Let z be the current state. |
| 2. Push the value $local(z, x) to the stack. |
| |
| Step_read/global.get x |
| 1. Let z be the current state. |
| 2. Push the value $global(z, x).VALUE to the stack. |
| |
| Step_read/table.get x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If (i >= |$table(z, x).REFS|), then: |
| a. Trap. |
| 5. Push the value $table(z, x).REFS[i] to the stack. |
| |
| Step_read/table.size x |
| 1. Let z be the current state. |
| 2. Let n be |$table(z, x).REFS|. |
| 3. Push the value (I32.CONST n) to the stack. |
| |
| Step_read/table.fill x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value val from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST i) from the stack. |
| 8. If ((i + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| 9. If (n = 0), then: |
| a. Do nothing. |
| 10. Else: |
| a. Push the value (I32.CONST i) to the stack. |
| b. Push the value val to the stack. |
| c. Execute the instruction (TABLE.SET x). |
| d. Push the value (I32.CONST (i + 1)) to the stack. |
| e. Push the value val to the stack. |
| f. Push the value (I32.CONST (n - 1)) to the stack. |
| g. Execute the instruction (TABLE.FILL x). |
| |
| Step_read/table.copy x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$table(z, y).REFS|), then: |
| a. Trap. |
| 9. If ((j + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. If (j <= i), then: |
| 1) Push the value (I32.CONST j) to the stack. |
| 2) Push the value (I32.CONST i) to the stack. |
| 3) Execute the instruction (TABLE.GET y). |
| 4) Execute the instruction (TABLE.SET x). |
| 5) Push the value (I32.CONST (j + 1)) to the stack. |
| 6) Push the value (I32.CONST (i + 1)) to the stack. |
| b. Else: |
| 1) Push the value (I32.CONST ((j + n) - 1)) to the stack. |
| 2) Push the value (I32.CONST ((i + n) - 1)) to the stack. |
| 3) Execute the instruction (TABLE.GET y). |
| 4) Execute the instruction (TABLE.SET x). |
| 5) Push the value (I32.CONST j) to the stack. |
| 6) Push the value (I32.CONST i) to the stack. |
| c. Push the value (I32.CONST (n - 1)) to the stack. |
| d. Execute the instruction (TABLE.COPY x y). |
| |
| Step_read/table.init x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$elem(z, y).REFS|), then: |
| a. Trap. |
| 9. If ((j + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. Assert: Due to validation, (i < |$elem(z, y).REFS|). |
| b. Push the value (I32.CONST j) to the stack. |
| c. Push the value $elem(z, y).REFS[i] to the stack. |
| d. Execute the instruction (TABLE.SET x). |
| e. Push the value (I32.CONST (j + 1)) to the stack. |
| f. Push the value (I32.CONST (i + 1)) to the stack. |
| g. Push the value (I32.CONST (n - 1)) to the stack. |
| h. Execute the instruction (TABLE.INIT x y). |
| |
| Step_read/load nt loadop_? ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If loadop_? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| b. Let c be $nbytes__1^-1(nt, $mem(z, 0).BYTES[(i + ao.OFFSET) : ($size(nt) / 8)]). |
| c. Push the value (nt.CONST c) to the stack. |
| 5. Else: |
| a. Assert: Due to validation, nt is Inn. |
| b. Let ?(loadop_0) be loadop_?. |
| c. Let n _ sx be loadop_0. |
| d. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| e. Let c be $ibytes__1^-1(n, $mem(z, 0).BYTES[(i + ao.OFFSET) : (n / 8)]). |
| f. Push the value (nt.CONST $extend__(n, $size(nt), sx, c)) to the stack. |
| |
| Step_read/vload V128 vloadop? ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. If vloadop? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($size(V128) / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| b. Let c be $vbytes__1^-1(V128, $mem(z, 0).BYTES[(i + ao.OFFSET) : ($size(V128) / 8)]). |
| c. Push the value (V128.CONST c) to the stack. |
| 5. Else: |
| a. Let ?(vloadop_0) be vloadop?. |
| b. If vloadop_0 is some SHAPE, then: |
| 1) Let (SHAPE M X N _ sx) be vloadop_0. |
| 2) If (((i + ao.OFFSET) + ((M * N) / 8)) > |$mem(z, 0).BYTES|), then: |
| a) Trap. |
| 3) Let j^N be $ibytes__1^-1(M, $mem(z, 0).BYTES[((i + ao.OFFSET) + ((k * M) / 8)) : (M / 8)])^(k<N). |
| 4) Let Jnn be $jsize^-1((M * 2)). |
| 5) Let c be $inv_lanes_(Jnn X N, $extend__(M, $jsize(Jnn), sx, j)^N). |
| 6) Push the value (V128.CONST c) to the stack. |
| c. If vloadop_0 is some SPLAT, then: |
| 1) Let (SPLAT N) be vloadop_0. |
| 2) If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, 0).BYTES|), then: |
| a) Trap. |
| 3) Let M be (128 / N). |
| 4) Let Jnn be $jsize^-1(N). |
| 5) Let j be $ibytes__1^-1(N, $mem(z, 0).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 6) Let c be $inv_lanes_(Jnn X M, j^M). |
| 7) Push the value (V128.CONST c) to the stack. |
| d. If vloadop_0 is some ZERO, then: |
| 1) Let (ZERO N) be vloadop_0. |
| 2) If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, 0).BYTES|), then: |
| a) Trap. |
| 3) Let j be $ibytes__1^-1(N, $mem(z, 0).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 4) Let c be $extend__(N, 128, U, j). |
| 5) Push the value (V128.CONST c) to the stack. |
| |
| Step_read/vload_lane V128 N ao j |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 3. Pop the value (V128.CONST c_1) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 7. Let M be (128 / N). |
| 8. Let Jnn be $jsize^-1(N). |
| 9. Let k be $ibytes__1^-1(N, $mem(z, 0).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 10. Let c be $inv_lanes_(Jnn X M, $lanes_(Jnn X M, c_1) with [j] replaced by k). |
| 11. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/memory.size |
| 1. Let z be the current state. |
| 2. Let ((n * 64) * $Ki()) be |$mem(z, 0).BYTES|. |
| 3. Push the value (I32.CONST n) to the stack. |
| |
| Step_read/memory.fill |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value val from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST i) from the stack. |
| 8. If ((i + n) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 9. If (n = 0), then: |
| a. Do nothing. |
| 10. Else: |
| a. Push the value (I32.CONST i) to the stack. |
| b. Push the value val to the stack. |
| c. Execute the instruction (STORE I32 ?(8) $memarg0()). |
| d. Push the value (I32.CONST (i + 1)) to the stack. |
| e. Push the value val to the stack. |
| f. Push the value (I32.CONST (n - 1)) to the stack. |
| g. Execute the instruction MEMORY.FILL. |
| |
| Step_read/memory.copy |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 9. If ((j + n) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. If (j <= i), then: |
| 1) Push the value (I32.CONST j) to the stack. |
| 2) Push the value (I32.CONST i) to the stack. |
| 3) Execute the instruction (LOAD I32 ?(8 _ U) $memarg0()). |
| 4) Execute the instruction (STORE I32 ?(8) $memarg0()). |
| 5) Push the value (I32.CONST (j + 1)) to the stack. |
| 6) Push the value (I32.CONST (i + 1)) to the stack. |
| b. Else: |
| 1) Push the value (I32.CONST ((j + n) - 1)) to the stack. |
| 2) Push the value (I32.CONST ((i + n) - 1)) to the stack. |
| 3) Execute the instruction (LOAD I32 ?(8 _ U) $memarg0()). |
| 4) Execute the instruction (STORE I32 ?(8) $memarg0()). |
| 5) Push the value (I32.CONST j) to the stack. |
| 6) Push the value (I32.CONST i) to the stack. |
| c. Push the value (I32.CONST (n - 1)) to the stack. |
| d. Execute the instruction MEMORY.COPY. |
| |
| Step_read/memory.init x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST j) from the stack. |
| 8. If ((i + n) > |$data(z, x).BYTES|), then: |
| a. Trap. |
| 9. If ((j + n) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. Assert: Due to validation, (i < |$data(z, x).BYTES|). |
| b. Push the value (I32.CONST j) to the stack. |
| c. Push the value (I32.CONST $data(z, x).BYTES[i]) to the stack. |
| d. Execute the instruction (STORE I32 ?(8) $memarg0()). |
| e. Push the value (I32.CONST (j + 1)) to the stack. |
| f. Push the value (I32.CONST (i + 1)) to the stack. |
| g. Push the value (I32.CONST (n - 1)) to the stack. |
| h. Execute the instruction (MEMORY.INIT x). |
| |
| Step/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 val from the stack. |
| 4. Perform $with_local(z, x, val). |
| |
| Step/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 val from the stack. |
| 4. Perform $with_global(z, x, val). |
| |
| Step/table.set x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 3. Pop the value ref from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (i >= |$table(z, x).REFS|), then: |
| a. Trap. |
| 7. Perform $with_table(z, x, i, ref). |
| |
| Step/table.grow x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 5. Pop the value ref from the stack. |
| 6. Either: |
| a. Let ti be $growtable($table(z, x), n, ref). |
| b. Push the value (I32.CONST |$table(z, x).REFS|) to the stack. |
| c. Perform $with_tableinst(z, x, ti). |
| 7. Or: |
| a. Push the value (I32.CONST $inv_signed_(32, (- 1))) to the stack. |
| |
| Step/elem.drop x |
| 1. Let z be the current state. |
| 2. Perform $with_elem(z, x, []). |
| |
| Step/store nt sz? ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (nt'.CONST c) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, (nt = nt'). |
| 7. If sz? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($size(nt') / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| b. Let b* be $nbytes_(nt', c). |
| c. Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(nt') / 8), b*). |
| 8. Else: |
| a. Assert: Due to validation, nt' is Inn. |
| b. Let ?(n) be sz?. |
| c. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then: |
| 1) Trap. |
| d. Let b* be $ibytes_(n, $wrap__($size(nt'), n, c)). |
| e. Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*). |
| |
| Step/vstore V128 ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 3. Pop the value (V128.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + ($size(V128) / 8)) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $vbytes_(V128, c). |
| 8. Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(V128) / 8), b*). |
| |
| Step/vstore_lane V128 N ao j |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 3. Pop the value (V128.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + N) > |$mem(z, 0).BYTES|), then: |
| a. Trap. |
| 7. Let M be (128 / N). |
| 8. Let Jnn be $jsize^-1(N). |
| 9. Assert: Due to validation, (j < |$lanes_(Jnn X M, c)|). |
| 10. Let b* be $ibytes_(N, $lanes_(Jnn X M, c)[j]). |
| 11. Perform $with_mem(z, 0, (i + ao.OFFSET), (N / 8), b*). |
| |
| Step/memory.grow |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Either: |
| a. Let mi be $growmemory($mem(z, 0), n). |
| b. Push the value (I32.CONST (|$mem(z, 0).BYTES| / (64 * $Ki()))) to the stack. |
| c. Perform $with_meminst(z, 0, mi). |
| 5. Or: |
| a. Push the value (I32.CONST $inv_signed_(32, (- 1))) to the stack. |
| |
| Step/data.drop x |
| 1. Let z be the current state. |
| 2. Perform $with_data(z, x, []). |
| |
| Ki |
| 1. Return 1024. |
| |
| min i j |
| 1. If (i <= j), then: |
| a. Return i. |
| 2. Return j. |
| |
| sum n''* |
| 1. If (n''* = []), then: |
| a. Return 0. |
| 2. Let [n] :: n'* be n''*. |
| 3. Return (n + $sum(n'*)). |
| |
| opt_ `X X* |
| 1. If (X* = []), then: |
| a. Return ?(). |
| 2. If (|X*| = 1), then: |
| a. Let [w] be X*. |
| b. Return ?(w). |
| 3. Fail. |
| |
| list_ `X X? |
| 1. If X? is not defined, then: |
| a. Return []. |
| 2. Let ?(w) be X?. |
| 3. Return [w]. |
| |
| concat_ `X X* |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w*] :: w'** be X*. |
| 3. Return w* :: $concat_(`X, w'**). |
| |
| setproduct2_ `X w_1 X* |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w'*] :: w** be X*. |
| 3. Return [[w_1] :: w'*] :: $setproduct2_(`X, w_1, w**). |
| |
| setproduct1_ `X X* w** |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w_1] :: w'* be X*. |
| 3. Return $setproduct2_(`X, w_1, w**) :: $setproduct1_(`X, w'*, w**). |
| |
| setproduct_ `X X* |
| 1. If (X* = []), then: |
| a. Return [[]]. |
| 2. Let [w_1*] :: w** be X*. |
| 3. Return $setproduct1_(`X, w_1*, $setproduct_(`X, w**)). |
| |
| signif N |
| 1. If (N = 32), then: |
| a. Return 23. |
| 2. If (N = 64), then: |
| a. Return 52. |
| 3. Fail. |
| |
| expon N |
| 1. If (N = 32), then: |
| a. Return 8. |
| 2. If (N = 64), then: |
| a. Return 11. |
| 3. Fail. |
| |
| M N |
| 1. Return $signif(N). |
| |
| E N |
| 1. Return $expon(N). |
| |
| fzero N |
| 1. Return (POS (SUBNORM 0)). |
| |
| fone N |
| 1. Return (POS (NORM 1 0)). |
| |
| canon_ N |
| 1. Return (2 ^ ($signif(N) - 1)). |
| |
| lanetype Lnn X N |
| 1. Return Lnn. |
| |
| size valtype |
| 1. If (valtype = I32), then: |
| a. Return 32. |
| 2. If (valtype = I64), then: |
| a. Return 64. |
| 3. If (valtype = F32), then: |
| a. Return 32. |
| 4. If (valtype = F64), then: |
| a. Return 64. |
| 5. If (valtype = V128), then: |
| a. Return 128. |
| 6. Fail. |
| |
| psize packtype |
| 1. If (packtype = I8), then: |
| a. Return 8. |
| 2. Assert: Due to validation, (packtype = I16). |
| 3. Return 16. |
| |
| lsize lanetype |
| 1. If lanetype is numtype, then: |
| a. Return $size(lanetype). |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return $psize(lanetype). |
| |
| isize Inn |
| 1. Return $size(Inn). |
| |
| jsize Jnn |
| 1. Return $lsize(Jnn). |
| |
| fsize Fnn |
| 1. Return $size(Fnn). |
| |
| sizenn nt |
| 1. Return $size(nt). |
| |
| sizenn1 nt |
| 1. Return $size(nt). |
| |
| sizenn2 nt |
| 1. Return $size(nt). |
| |
| lsizenn lt |
| 1. Return $lsize(lt). |
| |
| lsizenn1 lt |
| 1. Return $lsize(lt). |
| |
| lsizenn2 lt |
| 1. Return $lsize(lt). |
| |
| inv_isize n |
| 1. If (n = 32), then: |
| a. Return I32. |
| 2. If (n = 64), then: |
| a. Return I64. |
| 3. Fail. |
| |
| inv_jsize n |
| 1. If (n = 8), then: |
| a. Return I8. |
| 2. If (n = 16), then: |
| a. Return I16. |
| 3. If (n = 32), then: |
| a. Return I32. |
| 4. If (n = 64), then: |
| a. Return I64. |
| 5. Fail. |
| |
| inv_fsize n |
| 1. If (n = 32), then: |
| a. Return F32. |
| 2. If (n = 64), then: |
| a. Return F64. |
| 3. Fail. |
| |
| zero numtype |
| 1. If numtype is Inn, then: |
| a. Return 0. |
| 2. Assert: Due to validation, numtype is Fnn. |
| 3. Return $fzero($size(numtype)). |
| |
| dim Lnn X N |
| 1. Return N. |
| |
| shsize Lnn X N |
| 1. Return ($lsize(Lnn) * N). |
| |
| concat_bytes byte* |
| 1. If (byte* = []), then: |
| a. Return []. |
| 2. Let [b*] :: b'** be byte*. |
| 3. Return b* :: $concat_bytes(b'**). |
| |
| unpack lanetype |
| 1. If lanetype is numtype, then: |
| a. Return lanetype. |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return I32. |
| |
| shunpack Lnn X N |
| 1. Return $unpack(Lnn). |
| |
| funcsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some FUNC, then: |
| a. Let (FUNC ft) be externtype_0. |
| b. Return [ft] :: $funcsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $funcsxt(xt*). |
| |
| globalsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some GLOBAL, then: |
| a. Let (GLOBAL gt) be externtype_0. |
| b. Return [gt] :: $globalsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $globalsxt(xt*). |
| |
| tablesxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some TABLE, then: |
| a. Let (TABLE tt) be externtype_0. |
| b. Return [tt] :: $tablesxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $tablesxt(xt*). |
| |
| memsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some MEM, then: |
| a. Let (MEM mt) be externtype_0. |
| b. Return [mt] :: $memsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $memsxt(xt*). |
| |
| dataidx_instr instr |
| 1. If instr is some MEMORY.INIT, then: |
| a. Let (MEMORY.INIT x) be instr. |
| b. Return [x]. |
| 2. If instr is some DATA.DROP, then: |
| a. Let (DATA.DROP x) be instr. |
| b. Return [x]. |
| 3. Return []. |
| |
| dataidx_instrs instr''* |
| 1. If (instr''* = []), then: |
| a. Return []. |
| 2. Let [instr] :: instr'* be instr''*. |
| 3. Return $dataidx_instr(instr) :: $dataidx_instrs(instr'*). |
| |
| dataidx_expr in* |
| 1. Return $dataidx_instrs(in*). |
| |
| dataidx_func (FUNC x loc* e) |
| 1. Return $dataidx_expr(e). |
| |
| dataidx_funcs func''* |
| 1. If (func''* = []), then: |
| a. Return []. |
| 2. Let [func] :: func'* be func''*. |
| 3. Return $dataidx_func(func) :: $dataidx_funcs(func'*). |
| |
| memarg0 |
| 1. Return { ALIGN: 0; OFFSET: 0 }. |
| |
| bool b |
| 1. If (b = false), then: |
| a. Return 0. |
| 2. Assert: Due to validation, (b = true). |
| 3. Return 1. |
| |
| signed_ N i |
| 1. If (i < (2 ^ (N - 1))), then: |
| a. Return i. |
| 2. Assert: Due to validation, ((2 ^ (N - 1)) <= i). |
| 3. Assert: Due to validation, (i < (2 ^ N)). |
| 4. Return (i - (2 ^ N)). |
| |
| inv_signed_ N i |
| 1. If ((0 <= i) /\ (i < (2 ^ (N - 1)))), then: |
| a. Return i. |
| 2. Assert: Due to validation, ((- (2 ^ (N - 1))) <= i). |
| 3. Assert: Due to validation, (i < 0). |
| 4. Return (i + (2 ^ N)). |
| |
| sat_u_ N i |
| 1. If (i < 0), then: |
| a. Return 0. |
| 2. If (i > ((2 ^ N) - 1)), then: |
| a. Return ((2 ^ N) - 1). |
| 3. Return i. |
| |
| sat_s_ N i |
| 1. If (i < (- (2 ^ (N - 1)))), then: |
| a. Return (- (2 ^ (N - 1))). |
| 2. If (i > ((2 ^ (N - 1)) - 1)), then: |
| a. Return ((2 ^ (N - 1)) - 1). |
| 3. Return i. |
| |
| unop_ numtype unop_ iN |
| 1. If numtype is Inn, then: |
| a. If (unop_ = CLZ), then: |
| 1) Return [$iclz_($sizenn(numtype), iN)]. |
| b. If (unop_ = CTZ), then: |
| 1) Return [$ictz_($sizenn(numtype), iN)]. |
| c. If (unop_ = POPCNT), then: |
| 1) Return [$ipopcnt_($sizenn(numtype), iN)]. |
| d. If unop_ is some EXTEND, then: |
| 1) Let (EXTEND N) be unop_. |
| 2) Return [$extend__(N, $sizenn(numtype), S, $wrap__($sizenn(numtype), N, iN))]. |
| 2. Assert: Due to validation, numtype is Fnn. |
| 3. If (unop_ = ABS), then: |
| a. Return $fabs_($sizenn(numtype), iN). |
| 4. If (unop_ = NEG), then: |
| a. Return $fneg_($sizenn(numtype), iN). |
| 5. If (unop_ = SQRT), then: |
| a. Return $fsqrt_($sizenn(numtype), iN). |
| 6. If (unop_ = CEIL), then: |
| a. Return $fceil_($sizenn(numtype), iN). |
| 7. If (unop_ = FLOOR), then: |
| a. Return $ffloor_($sizenn(numtype), iN). |
| 8. If (unop_ = TRUNC), then: |
| a. Return $ftrunc_($sizenn(numtype), iN). |
| 9. Assert: Due to validation, (unop_ = NEAREST). |
| 10. Return $fnearest_($sizenn(numtype), iN). |
| |
| iadd_ N i_1 i_2 |
| 1. Return ((i_1 + i_2) \ (2 ^ N)). |
| |
| idiv_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_2 = 0), then: |
| 1) Return ?(). |
| b. Return ?($truncz((i_1 / i_2))). |
| 2. Assert: Due to validation, (sx = S). |
| 3. If (i_2 = 0), then: |
| a. Return ?(). |
| 4. If (($signed_(N, i_1) / $signed_(N, i_2)) = (2 ^ (N - 1))), then: |
| a. Return ?(). |
| 5. Return ?($inv_signed_(N, $truncz(($signed_(N, i_1) / $signed_(N, i_2))))). |
| |
| imul_ N i_1 i_2 |
| 1. Return ((i_1 * i_2) \ (2 ^ N)). |
| |
| irem_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_2 = 0), then: |
| 1) Return ?(). |
| b. Return ?((i_1 - (i_2 * $truncz((i_1 / i_2))))). |
| 2. Assert: Due to validation, (sx = S). |
| 3. If (i_2 = 0), then: |
| a. Return ?(). |
| 4. Let j_1 be $signed_(N, i_1). |
| 5. Let j_2 be $signed_(N, i_2). |
| 6. Return ?($inv_signed_(N, (j_1 - (j_2 * $truncz((j_1 / j_2)))))). |
| |
| isub_ N i_1 i_2 |
| 1. Return ((((2 ^ N) + i_1) - i_2) \ (2 ^ N)). |
| |
| binop_ numtype binop_ iN_1 iN_2 |
| 1. If numtype is Inn, then: |
| a. If (binop_ = ADD), then: |
| 1) Return [$iadd_($sizenn(numtype), iN_1, iN_2)]. |
| b. If (binop_ = SUB), then: |
| 1) Return [$isub_($sizenn(numtype), iN_1, iN_2)]. |
| c. If (binop_ = MUL), then: |
| 1) Return [$imul_($sizenn(numtype), iN_1, iN_2)]. |
| d. If binop_ is some DIV, then: |
| 1) Let (DIV sx) be binop_. |
| 2) Return $list_(`num_((Inn : Inn <: numtype)), $idiv_($sizenn(numtype), sx, iN_1, iN_2)). |
| e. If binop_ is some REM, then: |
| 1) Let (REM sx) be binop_. |
| 2) Return $list_(`num_((Inn : Inn <: numtype)), $irem_($sizenn(numtype), sx, iN_1, iN_2)). |
| f. If (binop_ = AND), then: |
| 1) Return [$iand_($sizenn(numtype), iN_1, iN_2)]. |
| g. If (binop_ = OR), then: |
| 1) Return [$ior_($sizenn(numtype), iN_1, iN_2)]. |
| h. If (binop_ = XOR), then: |
| 1) Return [$ixor_($sizenn(numtype), iN_1, iN_2)]. |
| i. If (binop_ = SHL), then: |
| 1) Return [$ishl_($sizenn(numtype), iN_1, iN_2)]. |
| j. If binop_ is some SHR, then: |
| 1) Let (SHR sx) be binop_. |
| 2) Return [$ishr_($sizenn(numtype), sx, iN_1, iN_2)]. |
| k. If (binop_ = ROTL), then: |
| 1) Return [$irotl_($sizenn(numtype), iN_1, iN_2)]. |
| l. If (binop_ = ROTR), then: |
| 1) Return [$irotr_($sizenn(numtype), iN_1, iN_2)]. |
| 2. Assert: Due to validation, numtype is Fnn. |
| 3. If (binop_ = ADD), then: |
| a. Return $fadd_($sizenn(numtype), iN_1, iN_2). |
| 4. If (binop_ = SUB), then: |
| a. Return $fsub_($sizenn(numtype), iN_1, iN_2). |
| 5. If (binop_ = MUL), then: |
| a. Return $fmul_($sizenn(numtype), iN_1, iN_2). |
| 6. If (binop_ = DIV), then: |
| a. Return $fdiv_($sizenn(numtype), iN_1, iN_2). |
| 7. If (binop_ = MIN), then: |
| a. Return $fmin_($sizenn(numtype), iN_1, iN_2). |
| 8. If (binop_ = MAX), then: |
| a. Return $fmax_($sizenn(numtype), iN_1, iN_2). |
| 9. Assert: Due to validation, (binop_ = COPYSIGN). |
| 10. Return $fcopysign_($sizenn(numtype), iN_1, iN_2). |
| |
| ieqz_ N i_1 |
| 1. Return $bool((i_1 = 0)). |
| |
| testop_ Inn EQZ iN |
| 1. Return $ieqz_($sizenn(Inn), iN). |
| |
| ieq_ N i_1 i_2 |
| 1. Return $bool((i_1 = i_2)). |
| |
| ige_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 >= i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) >= $signed_(N, i_2))). |
| |
| igt_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 > i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) > $signed_(N, i_2))). |
| |
| ile_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 <= i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) <= $signed_(N, i_2))). |
| |
| ilt_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 < i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) < $signed_(N, i_2))). |
| |
| ine_ N i_1 i_2 |
| 1. Return $bool((i_1 =/= i_2)). |
| |
| relop_ numtype relop_ iN_1 iN_2 |
| 1. If numtype is Inn, then: |
| a. If (relop_ = EQ), then: |
| 1) Return $ieq_($sizenn(numtype), iN_1, iN_2). |
| b. If (relop_ = NE), then: |
| 1) Return $ine_($sizenn(numtype), iN_1, iN_2). |
| c. If relop_ is some LT, then: |
| 1) Let (LT sx) be relop_. |
| 2) Return $ilt_($sizenn(numtype), sx, iN_1, iN_2). |
| d. If relop_ is some GT, then: |
| 1) Let (GT sx) be relop_. |
| 2) Return $igt_($sizenn(numtype), sx, iN_1, iN_2). |
| e. If relop_ is some LE, then: |
| 1) Let (LE sx) be relop_. |
| 2) Return $ile_($sizenn(numtype), sx, iN_1, iN_2). |
| f. If relop_ is some GE, then: |
| 1) Let (GE sx) be relop_. |
| 2) Return $ige_($sizenn(numtype), sx, iN_1, iN_2). |
| 2. Assert: Due to validation, numtype is Fnn. |
| 3. If (relop_ = EQ), then: |
| a. Return $feq_($sizenn(numtype), iN_1, iN_2). |
| 4. If (relop_ = NE), then: |
| a. Return $fne_($sizenn(numtype), iN_1, iN_2). |
| 5. If (relop_ = LT), then: |
| a. Return $flt_($sizenn(numtype), iN_1, iN_2). |
| 6. If (relop_ = GT), then: |
| a. Return $fgt_($sizenn(numtype), iN_1, iN_2). |
| 7. If (relop_ = LE), then: |
| a. Return $fle_($sizenn(numtype), iN_1, iN_2). |
| 8. Assert: Due to validation, (relop_ = GE). |
| 9. Return $fge_($sizenn(numtype), iN_1, iN_2). |
| |
| cvtop__ numtype numtype' cvtop iN_1 |
| 1. If (numtype is Inn /\ numtype' is Inn), then: |
| a. If cvtop is some EXTEND, then: |
| 1) Let (EXTEND sx) be cvtop. |
| 2) Return [$extend__($sizenn1(numtype), $sizenn2(numtype'), sx, iN_1)]. |
| b. If (cvtop = WRAP), then: |
| 1) Return [$wrap__($sizenn1(numtype), $sizenn2(numtype'), iN_1)]. |
| 2. If (numtype is Fnn /\ numtype' is Inn), then: |
| a. If cvtop is some TRUNC, then: |
| 1) Let (TRUNC sx) be cvtop. |
| 2) Return $list_(`num_((Inn_2 : Inn <: numtype)), $trunc__($sizenn1(numtype), $sizenn2(numtype'), sx, iN_1)). |
| b. If cvtop is some TRUNC_SAT, then: |
| 1) Let (TRUNC_SAT sx) be cvtop. |
| 2) Return $list_(`num_((Inn_2 : Inn <: numtype)), $trunc_sat__($sizenn1(numtype), $sizenn2(numtype'), sx, iN_1)). |
| 3. If (numtype is Inn /\ (numtype' is Fnn /\ cvtop is some CONVERT)), then: |
| a. Let (CONVERT sx) be cvtop. |
| b. Return [$convert__($sizenn1(numtype), $sizenn2(numtype'), sx, iN_1)]. |
| 4. If (numtype is Fnn /\ numtype' is Fnn), then: |
| a. If (cvtop = PROMOTE), then: |
| 1) Return $promote__($sizenn1(numtype), $sizenn2(numtype'), iN_1). |
| b. If (cvtop = DEMOTE), then: |
| 1) Return $demote__($sizenn1(numtype), $sizenn2(numtype'), iN_1). |
| 5. If (numtype is Inn /\ (numtype' is Fnn /\ ((cvtop = REINTERPRET) /\ ($size(numtype) = $size(numtype'))))), then: |
| a. Return [$reinterpret__(numtype, numtype', iN_1)]. |
| 6. Assert: Due to validation, numtype is Fnn. |
| 7. Assert: Due to validation, numtype' is Inn. |
| 8. Assert: Due to validation, (cvtop = REINTERPRET). |
| 9. Assert: Due to validation, ($size(numtype) = $size(numtype')). |
| 10. Return [$reinterpret__(numtype, numtype', iN_1)]. |
| |
| inez_ N i_1 |
| 1. Return $bool((i_1 =/= 0)). |
| |
| ineg_ N i_1 |
| 1. Return (((2 ^ N) - i_1) \ (2 ^ N)). |
| |
| iabs_ N i_1 |
| 1. If ($signed_(N, i_1) >= 0), then: |
| a. Return i_1. |
| 2. Return $ineg_(N, i_1). |
| |
| imin_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_1 <= i_2), then: |
| 1) Return i_1. |
| b. Return i_2. |
| 2. Assert: Due to validation, (sx = S). |
| 3. If ($signed_(N, i_1) <= $signed_(N, i_2)), then: |
| a. Return i_1. |
| 4. Return i_2. |
| |
| imax_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_1 >= i_2), then: |
| 1) Return i_1. |
| b. Return i_2. |
| 2. Assert: Due to validation, (sx = S). |
| 3. If ($signed_(N, i_1) >= $signed_(N, i_2)), then: |
| a. Return i_1. |
| 4. Return i_2. |
| |
| iadd_sat_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $sat_u_(N, (i_1 + i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $inv_signed_(N, $sat_s_(N, ($signed_(N, i_1) + $signed_(N, i_2)))). |
| |
| isub_sat_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $sat_u_(N, (i_1 - i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $inv_signed_(N, $sat_s_(N, ($signed_(N, i_1) - $signed_(N, i_2)))). |
| |
| packnum_ lanetype c |
| 1. If lanetype is numtype, then: |
| a. Return c. |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return $wrap__($size($unpack(lanetype)), $psize(lanetype), c). |
| |
| unpacknum_ lanetype c |
| 1. If lanetype is numtype, then: |
| a. Return c. |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return $extend__($psize(lanetype), $size($unpack(lanetype)), U, c). |
| |
| zeroop vcvtop |
| 1. If vcvtop is some EXTEND, then: |
| a. Return ?(). |
| 2. If vcvtop is some CONVERT, then: |
| a. Return ?(). |
| 3. If vcvtop is some TRUNC_SAT, then: |
| a. Let (TRUNC_SAT sx zero?) be vcvtop. |
| b. Return zero?. |
| 4. If vcvtop is some DEMOTE, then: |
| a. Let (DEMOTE zero) be vcvtop. |
| b. Return ?(zero). |
| 5. Assert: Due to validation, (vcvtop = PROMOTELOW). |
| 6. Return ?(). |
| |
| halfop vcvtop |
| 1. If vcvtop is some EXTEND, then: |
| a. Let (EXTEND half sx) be vcvtop. |
| b. Return ?(half). |
| 2. If vcvtop is some CONVERT, then: |
| a. Let (CONVERT half? sx) be vcvtop. |
| b. Return half?. |
| 3. If vcvtop is some TRUNC_SAT, then: |
| a. Return ?(). |
| 4. If vcvtop is some DEMOTE, then: |
| a. Return ?(). |
| 5. Assert: Due to validation, (vcvtop = PROMOTELOW). |
| 6. Return ?(LOW). |
| |
| half half i j |
| 1. If (half = LOW), then: |
| a. Return i. |
| 2. Assert: Due to validation, (half = HIGH). |
| 3. Return j. |
| |
| vvunop_ V128 NOT v128 |
| 1. Return $inot_($size(V128), v128). |
| |
| vvbinop_ V128 vvbinop v128_1 v128_2 |
| 1. If (vvbinop = AND), then: |
| a. Return $iand_($size(V128), v128_1, v128_2). |
| 2. If (vvbinop = ANDNOT), then: |
| a. Return $iandnot_($size(V128), v128_1, v128_2). |
| 3. If (vvbinop = OR), then: |
| a. Return $ior_($size(V128), v128_1, v128_2). |
| 4. Assert: Due to validation, (vvbinop = XOR). |
| 5. Return $ixor_($size(V128), v128_1, v128_2). |
| |
| vvternop_ V128 BITSELECT v128_1 v128_2 v128_3 |
| 1. Return $ibitselect_($size(V128), v128_1, v128_2, v128_3). |
| |
| vunop_ lanetype X M vunop_ v128_1 |
| 1. If lanetype is Jnn, then: |
| a. If (vunop_ = ABS), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let v128 be $inv_lanes_(lanetype X M, $iabs_($lsizenn(lanetype), lane_1)*). |
| 3) Return [v128]. |
| b. If (vunop_ = NEG), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let v128 be $inv_lanes_(lanetype X M, $ineg_($lsizenn(lanetype), lane_1)*). |
| 3) Return [v128]. |
| c. If (vunop_ = POPCNT), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let v128 be $inv_lanes_(lanetype X M, $ipopcnt_($lsizenn(lanetype), lane_1)*). |
| 3) Return [v128]. |
| 2. Assert: Due to validation, lanetype is Fnn. |
| 3. If (vunop_ = ABS), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fabs_($sizenn(lanetype), lane_1)*). |
| c. Let v128* be []. |
| d. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| e. Return v128*. |
| 4. If (vunop_ = NEG), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fneg_($sizenn(lanetype), lane_1)*). |
| c. Let v128* be []. |
| d. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| e. Return v128*. |
| 5. If (vunop_ = SQRT), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fsqrt_($sizenn(lanetype), lane_1)*). |
| c. Let v128* be []. |
| d. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| e. Return v128*. |
| 6. If (vunop_ = CEIL), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fceil_($sizenn(lanetype), lane_1)*). |
| c. Let v128* be []. |
| d. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| e. Return v128*. |
| 7. If (vunop_ = FLOOR), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $ffloor_($sizenn(lanetype), lane_1)*). |
| c. Let v128* be []. |
| d. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| e. Return v128*. |
| 8. If (vunop_ = TRUNC), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $ftrunc_($sizenn(lanetype), lane_1)*). |
| c. Let v128* be []. |
| d. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| e. Return v128*. |
| 9. Assert: Due to validation, (vunop_ = NEAREST). |
| 10. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 11. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fnearest_($sizenn(lanetype), lane_1)*). |
| 12. Let v128* be []. |
| 13. For each lane* in lane**, do: |
| a. Let v128 be $inv_lanes_(lanetype X M, lane*). |
| b. Append v128 to the v128*. |
| 14. Return v128*. |
| |
| vbinop_ lanetype X M vbinop_ v128_1 v128_2 |
| 1. If lanetype is Jnn, then: |
| a. If (vbinop_ = ADD), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 3) Let v128 be $inv_lanes_(lanetype X M, $iadd_($lsizenn(lanetype), lane_1, lane_2)*). |
| 4) Return [v128]. |
| b. If (vbinop_ = SUB), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 3) Let v128 be $inv_lanes_(lanetype X M, $isub_($lsizenn(lanetype), lane_1, lane_2)*). |
| 4) Return [v128]. |
| c. If vbinop_ is some MIN, then: |
| 1) Let (MIN sx) be vbinop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let v128 be $inv_lanes_(lanetype X M, $imin_($lsizenn(lanetype), sx, lane_1, lane_2)*). |
| 5) Return [v128]. |
| d. If vbinop_ is some MAX, then: |
| 1) Let (MAX sx) be vbinop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let v128 be $inv_lanes_(lanetype X M, $imax_($lsizenn(lanetype), sx, lane_1, lane_2)*). |
| 5) Return [v128]. |
| e. If vbinop_ is some ADD_SAT, then: |
| 1) Let (ADD_SAT sx) be vbinop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let v128 be $inv_lanes_(lanetype X M, $iadd_sat_($lsizenn(lanetype), sx, lane_1, lane_2)*). |
| 5) Return [v128]. |
| f. If vbinop_ is some SUB_SAT, then: |
| 1) Let (SUB_SAT sx) be vbinop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let v128 be $inv_lanes_(lanetype X M, $isub_sat_($lsizenn(lanetype), sx, lane_1, lane_2)*). |
| 5) Return [v128]. |
| g. If (vbinop_ = MUL), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 3) Let v128 be $inv_lanes_(lanetype X M, $imul_($lsizenn(lanetype), lane_1, lane_2)*). |
| 4) Return [v128]. |
| h. If (vbinop_ = AVGRU), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 3) Let v128 be $inv_lanes_(lanetype X M, $iavgr_($lsizenn(lanetype), U, lane_1, lane_2)*). |
| 4) Return [v128]. |
| i. If (vbinop_ = Q15MULR_SATS), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 3) Let v128 be $inv_lanes_(lanetype X M, $iq15mulr_sat_($lsizenn(lanetype), S, lane_1, lane_2)*). |
| 4) Return [v128]. |
| 2. Assert: Due to validation, lanetype is Fnn. |
| 3. If (vbinop_ = ADD), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fadd_($sizenn(lanetype), lane_1, lane_2)*). |
| d. Let v128* be []. |
| e. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| f. Return v128*. |
| 4. If (vbinop_ = SUB), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fsub_($sizenn(lanetype), lane_1, lane_2)*). |
| d. Let v128* be []. |
| e. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| f. Return v128*. |
| 5. If (vbinop_ = MUL), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fmul_($sizenn(lanetype), lane_1, lane_2)*). |
| d. Let v128* be []. |
| e. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| f. Return v128*. |
| 6. If (vbinop_ = DIV), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fdiv_($sizenn(lanetype), lane_1, lane_2)*). |
| d. Let v128* be []. |
| e. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| f. Return v128*. |
| 7. If (vbinop_ = MIN), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fmin_($sizenn(lanetype), lane_1, lane_2)*). |
| d. Let v128* be []. |
| e. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| f. Return v128*. |
| 8. If (vbinop_ = MAX), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fmax_($sizenn(lanetype), lane_1, lane_2)*). |
| d. Let v128* be []. |
| e. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| f. Return v128*. |
| 9. If (vbinop_ = PMIN), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fpmin_($sizenn(lanetype), lane_1, lane_2)*). |
| d. Let v128* be []. |
| e. For each lane* in lane**, do: |
| 1) Let v128 be $inv_lanes_(lanetype X M, lane*). |
| 2) Append v128 to the v128*. |
| f. Return v128*. |
| 10. Assert: Due to validation, (vbinop_ = PMAX). |
| 11. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 12. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 13. Let lane** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $fpmax_($sizenn(lanetype), lane_1, lane_2)*). |
| 14. Let v128* be []. |
| 15. For each lane* in lane**, do: |
| a. Let v128 be $inv_lanes_(lanetype X M, lane*). |
| b. Append v128 to the v128*. |
| 16. Return v128*. |
| |
| vrelop_ lanetype X M vrelop_ v128_1 v128_2 |
| 1. If lanetype is Jnn, then: |
| a. If (vrelop_ = EQ), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 3) Let lane_3* be []. |
| 4) For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| a) Let lane_3 be $extend__(1, $lsizenn(lanetype), S, $ieq_($lsizenn(lanetype), lane_1, lane_2)). |
| b) Append lane_3 to the lane_3*. |
| 5) Let v128 be $inv_lanes_(lanetype X M, lane_3*). |
| 6) Return v128. |
| b. If (vrelop_ = NE), then: |
| 1) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 2) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 3) Let lane_3* be []. |
| 4) For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| a) Let lane_3 be $extend__(1, $lsizenn(lanetype), S, $ine_($lsizenn(lanetype), lane_1, lane_2)). |
| b) Append lane_3 to the lane_3*. |
| 5) Let v128 be $inv_lanes_(lanetype X M, lane_3*). |
| 6) Return v128. |
| c. If vrelop_ is some LT, then: |
| 1) Let (LT sx) be vrelop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let lane_3* be []. |
| 5) For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| a) Let lane_3 be $extend__(1, $lsizenn(lanetype), S, $ilt_($lsizenn(lanetype), sx, lane_1, lane_2)). |
| b) Append lane_3 to the lane_3*. |
| 6) Let v128 be $inv_lanes_(lanetype X M, lane_3*). |
| 7) Return v128. |
| d. If vrelop_ is some GT, then: |
| 1) Let (GT sx) be vrelop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let lane_3* be []. |
| 5) For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| a) Let lane_3 be $extend__(1, $lsizenn(lanetype), S, $igt_($lsizenn(lanetype), sx, lane_1, lane_2)). |
| b) Append lane_3 to the lane_3*. |
| 6) Let v128 be $inv_lanes_(lanetype X M, lane_3*). |
| 7) Return v128. |
| e. If vrelop_ is some LE, then: |
| 1) Let (LE sx) be vrelop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let lane_3* be []. |
| 5) For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| a) Let lane_3 be $extend__(1, $lsizenn(lanetype), S, $ile_($lsizenn(lanetype), sx, lane_1, lane_2)). |
| b) Append lane_3 to the lane_3*. |
| 6) Let v128 be $inv_lanes_(lanetype X M, lane_3*). |
| 7) Return v128. |
| f. If vrelop_ is some GE, then: |
| 1) Let (GE sx) be vrelop_. |
| 2) Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 3) Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 4) Let lane_3* be []. |
| 5) For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| a) Let lane_3 be $extend__(1, $lsizenn(lanetype), S, $ige_($lsizenn(lanetype), sx, lane_1, lane_2)). |
| b) Append lane_3 to the lane_3*. |
| 6) Let v128 be $inv_lanes_(lanetype X M, lane_3*). |
| 7) Return v128. |
| 2. Assert: Due to validation, lanetype is Fnn. |
| 3. If (vrelop_ = EQ), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let Inn be $isize^-1($size(lanetype)). |
| d. Let lane_3* be []. |
| e. For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| 1) Let lane_3 be $extend__(1, $sizenn(lanetype), S, $feq_($sizenn(lanetype), lane_1, lane_2)). |
| 2) Append lane_3 to the lane_3*. |
| f. Let v128 be $inv_lanes_(Inn X M, lane_3*). |
| g. Return v128. |
| 4. If (vrelop_ = NE), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let Inn be $isize^-1($size(lanetype)). |
| d. Let lane_3* be []. |
| e. For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| 1) Let lane_3 be $extend__(1, $sizenn(lanetype), S, $fne_($sizenn(lanetype), lane_1, lane_2)). |
| 2) Append lane_3 to the lane_3*. |
| f. Let v128 be $inv_lanes_(Inn X M, lane_3*). |
| g. Return v128. |
| 5. If (vrelop_ = LT), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let Inn be $isize^-1($size(lanetype)). |
| d. Let lane_3* be []. |
| e. For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| 1) Let lane_3 be $extend__(1, $sizenn(lanetype), S, $flt_($sizenn(lanetype), lane_1, lane_2)). |
| 2) Append lane_3 to the lane_3*. |
| f. Let v128 be $inv_lanes_(Inn X M, lane_3*). |
| g. Return v128. |
| 6. If (vrelop_ = GT), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let Inn be $isize^-1($size(lanetype)). |
| d. Let lane_3* be []. |
| e. For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| 1) Let lane_3 be $extend__(1, $sizenn(lanetype), S, $fgt_($sizenn(lanetype), lane_1, lane_2)). |
| 2) Append lane_3 to the lane_3*. |
| f. Let v128 be $inv_lanes_(Inn X M, lane_3*). |
| g. Return v128. |
| 7. If (vrelop_ = LE), then: |
| a. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| b. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| c. Let Inn be $isize^-1($size(lanetype)). |
| d. Let lane_3* be []. |
| e. For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| 1) Let lane_3 be $extend__(1, $sizenn(lanetype), S, $fle_($sizenn(lanetype), lane_1, lane_2)). |
| 2) Append lane_3 to the lane_3*. |
| f. Let v128 be $inv_lanes_(Inn X M, lane_3*). |
| g. Return v128. |
| 8. Assert: Due to validation, (vrelop_ = GE). |
| 9. Let lane_1* be $lanes_(lanetype X M, v128_1). |
| 10. Let lane_2* be $lanes_(lanetype X M, v128_2). |
| 11. Let Inn be $isize^-1($size(lanetype)). |
| 12. Let lane_3* be []. |
| 13. For each lane_1 in lane_1* and lane_2 in lane_2*, do: |
| a. Let lane_3 be $extend__(1, $sizenn(lanetype), S, $fge_($sizenn(lanetype), lane_1, lane_2)). |
| b. Append lane_3 to the lane_3*. |
| 14. Let v128 be $inv_lanes_(Inn X M, lane_3*). |
| 15. Return v128. |
| |
| vcvtop__ lanetype' X M_1 lanetype X M_2 vcvtop iN_1 |
| 1. If lanetype' is Jnn, then: |
| a. If (lanetype is Jnn /\ vcvtop is some EXTEND), then: |
| 1) Let (EXTEND half sx) be vcvtop. |
| 2) Let iN_2 be $extend__($lsizenn1(lanetype'), $lsizenn2(lanetype), sx, iN_1). |
| 3) Return [iN_2]. |
| b. If (lanetype is Fnn /\ vcvtop is some CONVERT), then: |
| 1) Let (CONVERT half? sx) be vcvtop. |
| 2) Let fN_2 be $convert__($lsizenn1(lanetype'), $lsizenn2(lanetype), sx, iN_1). |
| 3) Return [fN_2]. |
| 2. Assert: Due to validation, lanetype' is Fnn. |
| 3. If (lanetype is Inn /\ vcvtop is some TRUNC_SAT), then: |
| a. Let (TRUNC_SAT sx zero?) be vcvtop. |
| b. Let iN_2? be $trunc_sat__($lsizenn1(lanetype'), $lsizenn2(lanetype), sx, iN_1). |
| c. Return $list_(`lane_((Inn_2 : Inn <: lanetype)), iN_2?). |
| 4. Assert: Due to validation, lanetype is Fnn. |
| 5. If (vcvtop = (DEMOTE ZERO)), then: |
| a. Let fN_2* be $demote__($lsizenn1(lanetype'), $lsizenn2(lanetype), iN_1). |
| b. Return fN_2*. |
| 6. Assert: Due to validation, (vcvtop = PROMOTELOW). |
| 7. Let fN_2* be $promote__($lsizenn1(lanetype'), $lsizenn2(lanetype), iN_1). |
| 8. Return fN_2*. |
| |
| vextunop__ Inn_1 X M_1 Inn_2 X M_2 (EXTADD_PAIRWISE sx) c_1 |
| 1. Let ci* be $lanes_(Inn_2 X M_2, c_1). |
| 2. Let [cj_1, cj_2]* be $concat__1^-1(`iN($lsizenn1((Inn_1 : Inn <: lanetype))), $extend__($lsizenn2(Inn_2), $lsizenn1(Inn_1), sx, ci)*). |
| 3. Let c be $inv_lanes_(Inn_1 X M_1, $iadd_($lsizenn1(Inn_1), cj_1, cj_2)*). |
| 4. Return c. |
| |
| vextbinop__ Inn_1 X M_1 Inn_2 X M_2 vextbinop_ c_1 c_2 |
| 1. If vextbinop_ is some EXTMUL, then: |
| a. Let (EXTMUL half sx) be vextbinop_. |
| b. Let ci_1* be $lanes_(Inn_2 X M_2, c_1)[$half(half, 0, M_1) : M_1]. |
| c. Let ci_2* be $lanes_(Inn_2 X M_2, c_2)[$half(half, 0, M_1) : M_1]. |
| d. Let c be $inv_lanes_(Inn_1 X M_1, $imul_($lsizenn1(Inn_1), $extend__($lsizenn2(Inn_2), $lsizenn1(Inn_1), sx, ci_1), $extend__($lsizenn2(Inn_2), $lsizenn1(Inn_1), sx, ci_2))*). |
| e. Return c. |
| 2. Assert: Due to validation, (vextbinop_ = DOTS). |
| 3. Let ci_1* be $lanes_(Inn_2 X M_2, c_1). |
| 4. Let ci_2* be $lanes_(Inn_2 X M_2, c_2). |
| 5. Let [cj_1, cj_2]* be $concat__1^-1(`iN($lsizenn1((Inn_1 : Inn <: lanetype))), $imul_($lsizenn1(Inn_1), $extend__($lsizenn2(Inn_2), $lsizenn1(Inn_1), S, ci_1), $extend__($lsizenn2(Inn_2), $lsizenn1(Inn_1), S, ci_2))*). |
| 6. Let c be $inv_lanes_(Inn_1 X M_1, $iadd_($lsizenn1(Inn_1), cj_1, cj_2)*). |
| 7. Return c. |
| |
| vshiftop_ Jnn X M vshiftop_ lane n |
| 1. If (vshiftop_ = SHL), then: |
| a. Return $ishl_($lsizenn(Jnn), lane, n). |
| 2. Assert: Due to validation, vshiftop_ is some SHR. |
| 3. Let (SHR sx) be vshiftop_. |
| 4. Return $ishr_($lsizenn(Jnn), sx, lane, n). |
| |
| default_ valtype |
| 1. If (valtype = I32), then: |
| a. Return (I32.CONST 0). |
| 2. If (valtype = I64), then: |
| a. Return (I64.CONST 0). |
| 3. If (valtype = F32), then: |
| a. Return (F32.CONST $fzero(32)). |
| 4. If (valtype = F64), then: |
| a. Return (F64.CONST $fzero(64)). |
| 5. If (valtype = V128), then: |
| a. Return (V128.CONST 0). |
| 6. If (valtype = FUNCREF), then: |
| a. Return (REF.NULL FUNCREF). |
| 7. Assert: Due to validation, (valtype = EXTERNREF). |
| 8. Return (REF.NULL EXTERNREF). |
| |
| funcsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some FUNC, then: |
| a. Let (FUNC fa) be externaddr_0. |
| b. Return [fa] :: $funcsxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $funcsxa(xv*). |
| |
| globalsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some GLOBAL, then: |
| a. Let (GLOBAL ga) be externaddr_0. |
| b. Return [ga] :: $globalsxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $globalsxa(xv*). |
| |
| tablesxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some TABLE, then: |
| a. Let (TABLE ta) be externaddr_0. |
| b. Return [ta] :: $tablesxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $tablesxa(xv*). |
| |
| memsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xv* be externaddr'*. |
| 3. If externaddr_0 is some MEM, then: |
| a. Let (MEM ma) be externaddr_0. |
| b. Return [ma] :: $memsxa(xv*). |
| 4. Let [externaddr] :: xv* be externaddr'*. |
| 5. Return $memsxa(xv*). |
| |
| store (s, f) |
| 1. Return. |
| |
| frame (s, f) |
| 1. Return f. |
| |
| funcaddr (s, f) |
| 1. Return f.MODULE.FUNCS. |
| |
| funcinst (s, f) |
| 1. Return s.FUNCS. |
| |
| globalinst (s, f) |
| 1. Return s.GLOBALS. |
| |
| tableinst (s, f) |
| 1. Return s.TABLES. |
| |
| meminst (s, f) |
| 1. Return s.MEMS. |
| |
| eleminst (s, f) |
| 1. Return s.ELEMS. |
| |
| datainst (s, f) |
| 1. Return s.DATAS. |
| |
| moduleinst (s, f) |
| 1. Return f.MODULE. |
| |
| type (s, f) x |
| 1. Return f.MODULE.TYPES[x]. |
| |
| func (s, f) x |
| 1. Return s.FUNCS[f.MODULE.FUNCS[x]]. |
| |
| global (s, f) x |
| 1. Return s.GLOBALS[f.MODULE.GLOBALS[x]]. |
| |
| table (s, f) x |
| 1. Return s.TABLES[f.MODULE.TABLES[x]]. |
| |
| mem (s, f) x |
| 1. Return s.MEMS[f.MODULE.MEMS[x]]. |
| |
| elem (s, f) x |
| 1. Return s.ELEMS[f.MODULE.ELEMS[x]]. |
| |
| data (s, f) x |
| 1. Return s.DATAS[f.MODULE.DATAS[x]]. |
| |
| local (s, f) x |
| 1. Return f.LOCALS[x]. |
| |
| with_local (s, f) x v |
| 1. Replace f.LOCALS[x] with v. |
| |
| with_global (s, f) x v |
| 1. Replace s.GLOBALS[f.MODULE.GLOBALS[x]].VALUE with v. |
| |
| with_table (s, f) x i r |
| 1. Replace s.TABLES[f.MODULE.TABLES[x]].REFS[i] with r. |
| |
| with_tableinst (s, f) x ti |
| 1. Replace s.TABLES[f.MODULE.TABLES[x]] with ti. |
| |
| with_mem (s, f) x i j b* |
| 1. Replace s.MEMS[f.MODULE.MEMS[x]].BYTES[i : j] with b*. |
| |
| with_meminst (s, f) x mi |
| 1. Replace s.MEMS[f.MODULE.MEMS[x]] with mi. |
| |
| with_elem (s, f) x r* |
| 1. Replace s.ELEMS[f.MODULE.ELEMS[x]].REFS with r*. |
| |
| with_data (s, f) x b* |
| 1. Replace s.DATAS[f.MODULE.DATAS[x]].BYTES with b*. |
| |
| growtable ti n r |
| 1. Let { TYPE: (([ i .. j? ]) rt); REFS: r'* } be ti. |
| 2. Let i' be (|r'*| + n). |
| 3. If (i' <= j)?, then: |
| a. Let ti' be { TYPE: (([ i' .. j? ]) rt); REFS: r'* :: r^n }. |
| b. Return ti'. |
| 4. Fail. |
| |
| growmemory mi n |
| 1. Let { TYPE: ([ i .. j? ]) PAGE; BYTES: b* } be mi. |
| 2. Let i' be ((|b*| / (64 * $Ki())) + n). |
| 3. If (i' <= j)?, then: |
| a. Let mi' be { TYPE: ([ i' .. j? ]) PAGE; BYTES: b* :: 0^(n * (64 * $Ki())) }. |
| b. Return mi'. |
| 4. Fail. |
| |
| blocktype z blocktype |
| 1. If (blocktype = (_RESULT ?())), then: |
| a. Return [] -> []. |
| 2. If blocktype is some _RESULT, then: |
| a. Let (_RESULT valtype_0?) be blocktype. |
| b. If valtype_0? is defined, then: |
| 1) Let ?(t) be valtype_0?. |
| 2) Return [] -> [t]. |
| 3. Assert: Due to validation, blocktype is some _IDX. |
| 4. Let (_IDX x) be blocktype. |
| 5. Return $type(z, x). |
| |
| funcs externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some FUNC, then: |
| a. Let (FUNC fa) be externaddr_0. |
| b. Return [fa] :: $funcs(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $funcs(externaddr'*). |
| |
| globals externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some GLOBAL, then: |
| a. Let (GLOBAL ga) be externaddr_0. |
| b. Return [ga] :: $globals(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $globals(externaddr'*). |
| |
| tables externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some TABLE, then: |
| a. Let (TABLE ta) be externaddr_0. |
| b. Return [ta] :: $tables(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $tables(externaddr'*). |
| |
| mems externaddr''* |
| 1. If (externaddr''* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: externaddr'* be externaddr''*. |
| 3. If externaddr_0 is some MEM, then: |
| a. Let (MEM ma) be externaddr_0. |
| b. Return [ma] :: $mems(externaddr'*). |
| 4. Let [externaddr] :: externaddr'* be externaddr''*. |
| 5. Return $mems(externaddr'*). |
| |
| allocfunc s moduleinst func |
| 1. Let (FUNC x local* expr) be func. |
| 2. Let fi be { TYPE: moduleinst.TYPES[x]; MODULE: moduleinst; CODE: func }. |
| 3. Let a be |s.FUNCS|. |
| 4. Append fi to the s.FUNCS. |
| 5. Return a. |
| |
| allocfuncs s moduleinst func''* |
| 1. If (func''* = []), then: |
| a. Return []. |
| 2. Let [func] :: func'* be func''*. |
| 3. Let fa be $allocfunc(s, moduleinst, func). |
| 4. Let fa'* be $allocfuncs(s, moduleinst, func'*). |
| 5. Return [fa] :: fa'*. |
| |
| allocglobal s globaltype val |
| 1. Let gi be { TYPE: globaltype; VALUE: val }. |
| 2. Let a be |s.GLOBALS|. |
| 3. Append gi to the s.GLOBALS. |
| 4. Return a. |
| |
| allocglobals s globaltype''* val''* |
| 1. If (globaltype''* = []), then: |
| a. Assert: Due to validation, (val''* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [globaltype] :: globaltype'* be globaltype''*. |
| b. Assert: Due to validation, (|val''*| >= 1). |
| c. Let [val] :: val'* be val''*. |
| d. Let ga be $allocglobal(s, globaltype, val). |
| e. Let ga'* be $allocglobals(s, globaltype'*, val'*). |
| f. Return [ga] :: ga'*. |
| |
| alloctable s (([ i .. j? ]) rt) |
| 1. Let ti be { TYPE: (([ i .. j? ]) rt); REFS: (REF.NULL rt)^i }. |
| 2. Let a be |s.TABLES|. |
| 3. Append ti to the s.TABLES. |
| 4. Return a. |
| |
| alloctables s tabletype''* |
| 1. If (tabletype''* = []), then: |
| a. Return []. |
| 2. Let [tabletype] :: tabletype'* be tabletype''*. |
| 3. Let ta be $alloctable(s, tabletype). |
| 4. Let ta'* be $alloctables(s, tabletype'*). |
| 5. Return [ta] :: ta'*. |
| |
| allocmem s ([ i .. j? ]) PAGE |
| 1. Let mi be { TYPE: ([ i .. j? ]) PAGE; BYTES: 0^(i * (64 * $Ki())) }. |
| 2. Let a be |s.MEMS|. |
| 3. Append mi to the s.MEMS. |
| 4. Return a. |
| |
| allocmems s memtype''* |
| 1. If (memtype''* = []), then: |
| a. Return []. |
| 2. Let [memtype] :: memtype'* be memtype''*. |
| 3. Let ma be $allocmem(s, memtype). |
| 4. Let ma'* be $allocmems(s, memtype'*). |
| 5. Return [ma] :: ma'*. |
| |
| allocelem s rt ref* |
| 1. Let ei be { TYPE: rt; REFS: ref* }. |
| 2. Let a be |s.ELEMS|. |
| 3. Append ei to the s.ELEMS. |
| 4. Return a. |
| |
| allocelems s reftype* ref''* |
| 1. If (ref''* = []), then: |
| a. Assert: Due to validation, (reftype* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [ref*] :: ref'** be ref''*. |
| b. Assert: Due to validation, (|reftype*| >= 1). |
| c. Let [rt] :: rt'* be reftype*. |
| d. Let ea be $allocelem(s, rt, ref*). |
| e. Let ea'* be $allocelems(s, rt'*, ref'**). |
| f. Return [ea] :: ea'*. |
| |
| allocdata s byte* |
| 1. Let di be { BYTES: byte* }. |
| 2. Let a be |s.DATAS|. |
| 3. Append di to the s.DATAS. |
| 4. Return a. |
| |
| allocdatas s byte''* |
| 1. If (byte''* = []), then: |
| a. Return []. |
| 2. Let [byte*] :: byte'** be byte''*. |
| 3. Let da be $allocdata(s, byte*). |
| 4. Let da'* be $allocdatas(s, byte'**). |
| 5. Return [da] :: da'*. |
| |
| instexport fa* ga* ta* ma* (EXPORT name externidx) |
| 1. If externidx is some FUNC, then: |
| a. Let (FUNC x) be externidx. |
| b. Return { NAME: name; ADDR: (FUNC fa*[x]) }. |
| 2. If externidx is some GLOBAL, then: |
| a. Let (GLOBAL x) be externidx. |
| b. Return { NAME: name; ADDR: (GLOBAL ga*[x]) }. |
| 3. If externidx is some TABLE, then: |
| a. Let (TABLE x) be externidx. |
| b. Return { NAME: name; ADDR: (TABLE ta*[x]) }. |
| 4. Assert: Due to validation, externidx is some MEM. |
| 5. Let (MEM x) be externidx. |
| 6. Return { NAME: name; ADDR: (MEM ma*[x]) }. |
| |
| allocmodule s module externaddr* val* ref** |
| 1. Let (MODULE type_0* import* func^n_func global_1* table_2* mem_3* elem_4* data_5* start? export*) be module. |
| 2. Let (DATA byte* datamode)^n_data be data_5*. |
| 3. Let (ELEM rt expr_2* elemmode)^n_elem be elem_4*. |
| 4. Let (MEMORY memtype)^n_mem be mem_3*. |
| 5. Let (TABLE tabletype)^n_table be table_2*. |
| 6. Let (GLOBAL globaltype expr_1)^n_global be global_1*. |
| 7. Let ft* be []. |
| 8. For each type_0 in type_0*, do: |
| a. Let (TYPE ft) be type_0. |
| b. Append ft to the ft*. |
| 9. Let fa_ex* be $funcs(externaddr*). |
| 10. Let ga_ex* be $globals(externaddr*). |
| 11. Let ma_ex* be $mems(externaddr*). |
| 12. Let ta_ex* be $tables(externaddr*). |
| 13. Let fa* be (|s.FUNCS| + i_func)^(i_func<n_func). |
| 14. Let ga* be (|s.GLOBALS| + i_global)^(i_global<n_global). |
| 15. Let ta* be (|s.TABLES| + i_table)^(i_table<n_table). |
| 16. Let ma* be (|s.MEMS| + i_mem)^(i_mem<n_mem). |
| 17. Let ea* be (|s.ELEMS| + i_elem)^(i_elem<n_elem). |
| 18. Let da* be (|s.DATAS| + i_data)^(i_data<n_data). |
| 19. Let xi* be []. |
| 20. For each export in export*, do: |
| a. Let xi be $instexport(fa_ex* :: fa*, ga_ex* :: ga*, ta_ex* :: ta*, ma_ex* :: ma*, export). |
| b. Append xi to the xi*. |
| 21. Let moduleinst be { TYPES: ft*; FUNCS: fa_ex* :: fa*; GLOBALS: ga_ex* :: ga*; TABLES: ta_ex* :: ta*; MEMS: ma_ex* :: ma*; ELEMS: ea*; DATAS: da*; EXPORTS: xi* }. |
| 22. Let funcaddr_0* be $allocfuncs(s, moduleinst, func^n_func). |
| 23. Assert: Due to validation, (funcaddr_0* = fa*). |
| 24. Let globaladdr_0* be $allocglobals(s, globaltype^n_global, val*). |
| 25. Assert: Due to validation, (globaladdr_0* = ga*). |
| 26. Let tableaddr_0* be $alloctables(s, tabletype^n_table). |
| 27. Assert: Due to validation, (tableaddr_0* = ta*). |
| 28. Let memaddr_0* be $allocmems(s, memtype^n_mem). |
| 29. Assert: Due to validation, (memaddr_0* = ma*). |
| 30. Let elemaddr_0* be $allocelems(s, rt^n_elem, ref**). |
| 31. Assert: Due to validation, (elemaddr_0* = ea*). |
| 32. Let dataaddr_0* be $allocdatas(s, byte*^n_data). |
| 33. Assert: Due to validation, (dataaddr_0* = da*). |
| 34. Return moduleinst. |
| |
| runelem (ELEM reftype expr* elemmode) i |
| 1. If (elemmode = PASSIVE), then: |
| a. Return []. |
| 2. If (elemmode = DECLARE), then: |
| a. Return [(ELEM.DROP i)]. |
| 3. Assert: Due to validation, elemmode is some ACTIVE. |
| 4. Let (ACTIVE x instr*) be elemmode. |
| 5. Let n be |expr*|. |
| 6. Return instr* :: [(I32.CONST 0), (I32.CONST n), (TABLE.INIT x i), (ELEM.DROP i)]. |
| |
| rundata (DATA byte* datamode) i |
| 1. If (datamode = PASSIVE), then: |
| a. Return []. |
| 2. Assert: Due to validation, datamode is some ACTIVE. |
| 3. Let (ACTIVE memidx_0 instr*) be datamode. |
| 4. Assert: Due to validation, (memidx_0 = 0). |
| 5. Let n be |byte*|. |
| 6. Return instr* :: [(I32.CONST 0), (I32.CONST n), (MEMORY.INIT i), (DATA.DROP i)]. |
| |
| instantiate s module externaddr* |
| 1. Let (MODULE type* import* func* global* table* mem* elem* data* start? export*) be module. |
| 2. Let functype* be []. |
| 3. For each type in type*, do: |
| a. Let (TYPE functype) be type. |
| b. Append functype to the functype*. |
| 4. Let n_D be |data*|. |
| 5. Let n_E be |elem*|. |
| 6. Let n_F be |func*|. |
| 7. Let expr_G* be []. |
| 8. For each global in global*, do: |
| a. Let (GLOBAL globaltype expr_G) be global. |
| b. Append expr_G to the expr_G*. |
| 9. Let expr_E** be []. |
| 10. For each elem in elem*, do: |
| a. Let (ELEM reftype expr_E* elemmode) be elem. |
| b. Append expr_E* to the expr_E**. |
| 11. Let instr_D* be $concat_(`instr, $rundata(data*[j], j)^(j<n_D)). |
| 12. Let instr_E* be $concat_(`instr, $runelem(elem*[i], i)^(i<n_E)). |
| 13. Let moduleinst_init be { TYPES: functype*; FUNCS: $funcs(externaddr*) :: (|s.FUNCS| + i_F)^(i_F<n_F); GLOBALS: $globals(externaddr*) }. |
| 14. Let f_init be { MODULE: moduleinst_init }. |
| 15. Let z be (s, f_init). |
| 16. Push the frame (FRAME_ 0 { $frame(z) }) to the stack. |
| 17. Let val* be []. |
| 18. For each expr_G in expr_G*, do: |
| a. Let [val] be $Eval_expr(z, expr_G). |
| b. Append val to the val*. |
| 19. Let ref** be []. |
| 20. For each expr_E* in expr_E**, do: |
| a. Let ref* be []. |
| b. For each expr_E in expr_E*, do: |
| 1) Let [ref] be $Eval_expr(z, expr_E). |
| 2) Append ref to the ref*. |
| c. Append ref* to the ref**. |
| 21. Pop the frame (FRAME_ 0 { $frame(z) }) from the stack. |
| 22. Let moduleinst be $allocmodule(s, module, externaddr*, val*, ref**). |
| 23. Let f be { MODULE: moduleinst }. |
| 24. Push the frame (FRAME_ 0 { f }) to the stack. |
| 25. Execute the sequence instr_E*. |
| 26. Execute the sequence instr_D*. |
| 27. If start? is defined, then: |
| a. Let ?((START x)) be start?. |
| b. Let instr_0 be (CALL x). |
| c. Execute the instruction instr_0. |
| 28. Pop the frame (FRAME_ 0 { f }) from the stack. |
| 29. Return f.MODULE. |
| |
| invoke s fa val^n |
| 1. Let f be { MODULE: {} }. |
| 2. Push the frame (FRAME_ 0 { (s, f) }) to the stack. |
| 3. Let t_1^n -> t_2* be $funcinst((s, f))[fa].TYPE. |
| 4. Pop the frame (FRAME_ 0 { _f }) from the stack. |
| 5. Let k be |t_2*|. |
| 6. Push the frame (FRAME_ k { f }) to the stack. |
| 7. Push the values val^n to the stack. |
| 8. Execute the instruction (CALL_ADDR fa). |
| 9. Pop the values val'^k from the stack. |
| 10. Pop the frame (FRAME_ k { f }) from the stack. |
| 11. Return val'^k. |
| |
| Eval_expr instr* |
| 1. Execute the sequence instr*. |
| 2. Pop the value val from the stack. |
| 3. Return [val]. |
| |
| == Complete. |
| Generating prose for Wasm 3.0... |
| spectec 0.5 generator |
| == Parsing... |
| == Elaboration... |
| == IL Validation... |
| == Running pass sideconditions... |
| == IL Validation after pass sideconditions... |
| == Translating to AL... |
| == Prose Generation... |
| |
| |
| |
| The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`{\mathit{comptype}}` if: |
| |
| |
| * The sub type :math:`{\mathrm{unroll}}({\mathit{deftype}})` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{typeuse}}^\ast}~{\mathit{comptype}})`. |
| |
| |
| |
| |
| The :ref:`expansion <aux-expand-typeuse>` of :math:`C` is :math:`{\mathit{comptype}}` if: |
| |
| |
| * Either: |
| |
| * The type use :math:`{\mathit{typeuse}}` is of the form :math:`{\mathit{deftype}}`. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`{\mathit{comptype}}`. |
| |
| * Or: |
| |
| * The type use :math:`{\mathit{typeuse}}` is of the form :math:`{\mathit{typeidx}}`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` is :math:`{\mathit{comptype}}`. |
| |
| |
| |
| |
| The :ref:`expansion <aux-expand-typeuse>` of :math:`C` is :math:`{\mathit{comptype}}` if: |
| |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`{\mathit{comptype}}`. |
| |
| |
| |
| |
| The :ref:`expansion <aux-expand-typeuse>` of :math:`C` is :math:`{\mathit{comptype}}` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` is :math:`{\mathit{comptype}}`. |
| |
| |
| |
| |
| :math:`{\mathit{fv}}_2` is not immutably reachable from :math:`{\mathit{fv}}_1`. |
| |
| |
| |
| |
| The number type :math:`{\mathit{numtype}}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The vector type :math:`{\mathit{vectype}}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The packed type :math:`{\mathit{packtype}}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The packed type :math:`{\mathit{packtype}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The number type :math:`{\mathit{numtype}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The vector type :math:`{\mathit{vectype}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{heaptype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The heap type :math:`{\mathit{heaptype}}` is of the form :math:`{\mathit{absheaptype}}`. |
| |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}` is of the form :math:`{\mathit{typeuse}}`. |
| |
| * The type use :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}` is of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{absheaptype}}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The type use :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{bot}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The reference type :math:`(\mathsf{ref}~{\mathsf{null}^?}~{\mathit{heaptype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The heap type :math:`{\mathit{heaptype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{valtype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{numtype}}`. |
| |
| * The number type :math:`{\mathit{numtype}}` is :ref:`valid <valid-val>`. |
| |
| * Or: |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{vectype}}`. |
| |
| * The vector type :math:`{\mathit{vectype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{reftype}}`. |
| |
| * The reference type :math:`{\mathit{reftype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{numtype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The number type :math:`{\mathit{numtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{vectype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The vector type :math:`{\mathit{vectype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{reftype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The reference type :math:`{\mathit{reftype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The value type :math:`\mathsf{bot}` is always :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The type use :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The type use :math:`{\mathit{typeuse}}` is of the form :math:`{\mathit{typeidx}}`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * Or: |
| |
| * The type use :math:`{\mathit{typeuse}}` is of the form :math:`(\mathsf{rec} {.} i)`. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| * Or: |
| |
| * The type use :math:`{\mathit{typeuse}}` is of the form :math:`{\mathit{deftype}}`. |
| |
| * The defined type :math:`{\mathit{deftype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The type use :math:`{\mathit{typeidx}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| |
| |
| |
| The type use :math:`(\mathsf{rec} {.} i)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| |
| |
| |
| The type use :math:`{\mathit{deftype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The defined type :math:`{\mathit{deftype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The result type :math:`{t^\ast}` is :ref:`valid <valid-val>` if: |
| |
| |
| * For all :math:`t` in :math:`{t^\ast}`: |
| |
| * The value type :math:`t` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The field type :math:`({\mathsf{mut}^?}~{\mathit{storagetype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The storage type :math:`{\mathit{storagetype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The storage type :math:`{\mathit{storagetype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The storage type :math:`{\mathit{storagetype}}` is of the form :math:`{\mathit{valtype}}`. |
| |
| * The value type :math:`{\mathit{valtype}}` is :ref:`valid <valid-val>`. |
| |
| * Or: |
| |
| * The storage type :math:`{\mathit{storagetype}}` is of the form :math:`{\mathit{packtype}}`. |
| |
| * The packed type :math:`{\mathit{packtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The storage type :math:`{\mathit{valtype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The value type :math:`{\mathit{valtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The storage type :math:`{\mathit{packtype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The packed type :math:`{\mathit{packtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The composite type :math:`{\mathit{comptype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The composite type :math:`{\mathit{comptype}}` is of the form :math:`(\mathsf{struct}~{{\mathit{fieldtype}}^\ast})`. |
| |
| * For all :math:`{\mathit{fieldtype}}` in :math:`{{\mathit{fieldtype}}^\ast}`: |
| |
| * The field type :math:`{\mathit{fieldtype}}` is :ref:`valid <valid-val>`. |
| |
| * Or: |
| |
| * The composite type :math:`{\mathit{comptype}}` is of the form :math:`(\mathsf{array}~{\mathit{fieldtype}})`. |
| |
| * The field type :math:`{\mathit{fieldtype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The composite type :math:`{\mathit{comptype}}` is of the form :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| * The result type :math:`{t_1^\ast}` is :ref:`valid <valid-val>`. |
| |
| * The result type :math:`{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The composite type :math:`(\mathsf{struct}~{{\mathit{fieldtype}}^\ast})` is :ref:`valid <valid-val>` if: |
| |
| |
| * For all :math:`{\mathit{fieldtype}}` in :math:`{{\mathit{fieldtype}}^\ast}`: |
| |
| * The field type :math:`{\mathit{fieldtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The composite type :math:`(\mathsf{array}~{\mathit{fieldtype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The field type :math:`{\mathit{fieldtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The composite type :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The result type :math:`{t_1^\ast}` is :ref:`valid <valid-val>`. |
| |
| * The result type :math:`{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The sub type :math:`(\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{typeuse}}^\ast}~{\mathit{comptype}})` is :ref:`valid <valid-val>` for :math:`i` if: |
| |
| |
| * The length of :math:`{{\mathit{typeuse}}^\ast}` is less than or equal to :math:`1`. |
| |
| * For all :math:`{\mathit{typeuse}}` in :math:`{{\mathit{typeuse}}^\ast}`: |
| |
| * The type use :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>`. |
| |
| * :math:`{\mathit{typeuse}} \prec i` is true. |
| |
| * The sub type :math:`{{\mathrm{unrollht}}}_{C}({\mathit{typeuse}})` is of the form :math:`(\mathsf{sub}~{{\mathit{typeuse}'}^\ast}~{\mathit{comptype}'})`. |
| |
| * :math:`{{\mathit{comptype}'}^\ast}` is the concatenation of all such :math:`{\mathit{comptype}'}`. |
| |
| * The composite type :math:`{\mathit{comptype}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{comptype}'}` in :math:`{{\mathit{comptype}'}^\ast}`: |
| |
| * The composite type :math:`{\mathit{comptype}}` :ref:`matches <match>` the composite type :math:`{\mathit{comptype}'}`. |
| |
| |
| |
| |
| The recursive type :math:`(\mathsf{rec}~{{\mathit{subtype}}^\ast})` is :ref:`valid <valid-val>` for :math:`i` if: |
| |
| |
| * Either: |
| |
| * The sub type sequence :math:`{{\mathit{subtype}}^\ast}` is empty. |
| |
| * Or: |
| |
| * The sub type sequence :math:`{{\mathit{subtype}}^\ast}` is of the form :math:`{\mathit{subtype}}_1~{{\mathit{subtype}'}^\ast}`. |
| |
| * The sub type :math:`{\mathit{subtype}}_1` is :ref:`valid <valid-val>` for :math:`i`. |
| |
| * The recursive type :math:`(\mathsf{rec}~{{\mathit{subtype}'}^\ast})` is :ref:`valid <valid-val>` for :math:`i + 1`. |
| |
| |
| |
| |
| The recursive type :math:`(\mathsf{rec})` is :ref:`valid <valid-val>` for :math:`i`. |
| |
| |
| |
| |
| The recursive type :math:`(\mathsf{rec}~{\mathit{subtype}}_1~{{\mathit{subtype}}^\ast})` is :ref:`valid <valid-val>` for :math:`i` if: |
| |
| |
| * The sub type :math:`{\mathit{subtype}}_1` is :ref:`valid <valid-val>` for :math:`i`. |
| |
| * The recursive type :math:`(\mathsf{rec}~{{\mathit{subtype}}^\ast})` is :ref:`valid <valid-val>` for :math:`i + 1`. |
| |
| |
| |
| |
| The defined type :math:`({\mathit{rectype}} {.} i)` is :ref:`valid <valid-val>` if: |
| |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the sub type sequence :math:`{{\mathit{subtype}}^{n}}` prepended to the field :math:`\mathsf{recs}`. |
| |
| * Under the context :math:`{C'}`, the recursive type :math:`{\mathit{rectype}}` is :ref:`valid <valid-val>` for :math:`0`. |
| |
| * The recursive type :math:`{\mathit{rectype}}` is of the form :math:`(\mathsf{rec}~{{\mathit{subtype}}^{n}})`. |
| |
| * :math:`i` is less than :math:`n`. |
| |
| |
| |
| |
| The composite type :math:`{\mathit{comptype}}_1` :ref:`matches <match>` the composite type :math:`{\mathit{comptype}}_2` if: |
| |
| |
| * Either: |
| |
| * The composite type :math:`{\mathit{comptype}}_1` is of the form :math:`(\mathsf{struct}~{{\mathit{ft}}_1^\ast}~{{\mathit{ft}'}_1^\ast})`. |
| |
| * The composite type :math:`{\mathit{comptype}}_2` is of the form :math:`(\mathsf{struct}~{{\mathit{ft}}_2^\ast})`. |
| |
| * For all :math:`{\mathit{ft}}_1` in :math:`{{\mathit{ft}}_1^\ast}`, and corresponding :math:`{\mathit{ft}}_2` in :math:`{{\mathit{ft}}_2^\ast}`: |
| |
| * The field type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the field type :math:`{\mathit{ft}}_2`. |
| |
| * Or: |
| |
| * The composite type :math:`{\mathit{comptype}}_1` is of the form :math:`(\mathsf{array}~{\mathit{ft}}_1)`. |
| |
| * The composite type :math:`{\mathit{comptype}}_2` is of the form :math:`(\mathsf{array}~{\mathit{ft}}_2)`. |
| |
| * The field type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the field type :math:`{\mathit{ft}}_2`. |
| * Or: |
| |
| * The composite type :math:`{\mathit{comptype}}_1` is of the form :math:`(\mathsf{func}~{t_{11}^\ast}~\rightarrow~{t_{12}^\ast})`. |
| |
| * The composite type :math:`{\mathit{comptype}}_2` is of the form :math:`(\mathsf{func}~{t_{21}^\ast}~\rightarrow~{t_{22}^\ast})`. |
| |
| * The result type :math:`{t_{21}^\ast}` :ref:`matches <match>` the result type :math:`{t_{11}^\ast}`. |
| |
| * The result type :math:`{t_{12}^\ast}` :ref:`matches <match>` the result type :math:`{t_{22}^\ast}`. |
| |
| |
| |
| |
| The composite type :math:`(\mathsf{struct}~{{\mathit{ft}}_1^\ast}~{{\mathit{ft}'}_1^\ast})` :ref:`matches <match>` the composite type :math:`(\mathsf{struct}~{{\mathit{ft}}_2^\ast})` if: |
| |
| |
| * For all :math:`{\mathit{ft}}_1` in :math:`{{\mathit{ft}}_1^\ast}`, and corresponding :math:`{\mathit{ft}}_2` in :math:`{{\mathit{ft}}_2^\ast}`: |
| |
| * The field type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the field type :math:`{\mathit{ft}}_2`. |
| |
| |
| |
| |
| The composite type :math:`(\mathsf{array}~{\mathit{ft}}_1)` :ref:`matches <match>` the composite type :math:`(\mathsf{array}~{\mathit{ft}}_2)` if: |
| |
| |
| * The field type :math:`{\mathit{ft}}_1` :ref:`matches <match>` the field type :math:`{\mathit{ft}}_2`. |
| |
| |
| |
| |
| The composite type :math:`(\mathsf{func}~{t_{11}^\ast}~\rightarrow~{t_{12}^\ast})` :ref:`matches <match>` the composite type :math:`(\mathsf{func}~{t_{21}^\ast}~\rightarrow~{t_{22}^\ast})` if: |
| |
| |
| * The result type :math:`{t_{21}^\ast}` :ref:`matches <match>` the result type :math:`{t_{11}^\ast}`. |
| |
| * The result type :math:`{t_{12}^\ast}` :ref:`matches <match>` the result type :math:`{t_{22}^\ast}`. |
| |
| |
| |
| |
| The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2` if: |
| |
| |
| * Either: |
| |
| * The defined type :math:`{{\mathrm{clos}}}_{C}({\mathit{deftype}}_1)` is of the form :math:`{{\mathrm{clos}}}_{C}({\mathit{deftype}}_2)`. |
| |
| * Or: |
| |
| * The sub type :math:`{\mathrm{unroll}}({\mathit{deftype}}_1)` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{typeuse}}^\ast}~{\mathit{ct}})`. |
| |
| * The length of :math:`{{\mathit{typeuse}}^\ast}` is greater than :math:`i`. |
| |
| * The type use :math:`{{\mathit{typeuse}}^\ast}{}[i]` :ref:`matches <match>` the heap type :math:`{\mathit{deftype}}_2`. |
| |
| |
| |
| |
| The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2` if: |
| |
| |
| * The defined type :math:`{{\mathrm{clos}}}_{C}({\mathit{deftype}}_1)` is of the form :math:`{{\mathrm{clos}}}_{C}({\mathit{deftype}}_2)`. |
| |
| |
| |
| |
| The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2` if: |
| |
| |
| * The sub type :math:`{\mathrm{unroll}}({\mathit{deftype}}_1)` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{typeuse}}^\ast}~{\mathit{ct}})`. |
| |
| * The length of :math:`{{\mathit{typeuse}}^\ast}` is greater than :math:`i`. |
| |
| * The type use :math:`{{\mathit{typeuse}}^\ast}{}[i]` :ref:`matches <match>` the heap type :math:`{\mathit{deftype}}_2`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{heaptype}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}_2` if: |
| |
| |
| * Either: |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`{\mathit{heaptype}}_1`. |
| |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}'}` is :ref:`valid <valid-val>`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}'}`. |
| |
| * The heap type :math:`{\mathit{heaptype}'}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}_2`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{eq}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{any}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{i{\scriptstyle 31}}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{eq}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{struct}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{eq}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{array}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{eq}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`{\mathit{deftype}}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{struct}`. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`(\mathsf{struct}~{{\mathit{fieldtype}}^\ast})`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`{\mathit{deftype}}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{array}`. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`(\mathsf{array}~{\mathit{fieldtype}})`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`{\mathit{deftype}}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{func}`. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`{\mathit{deftype}}_1`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`{\mathit{deftype}}_2`. |
| |
| * The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`{\mathit{typeidx}}`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}_2`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`{\mathit{typeidx}}`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` :ref:`matches <match>` the type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`(\mathsf{rec} {.} i)`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{struct}`. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~(\mathsf{struct}~{{\mathit{fieldtype}}^\ast}))`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`(\mathsf{rec} {.} i)`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{array}`. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~(\mathsf{array}~{\mathit{fieldtype}}))`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`(\mathsf{rec} {.} i)`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`\mathsf{func}`. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast}))`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`(\mathsf{rec} {.} i)`. |
| |
| * The length of :math:`{{\mathit{typeuse}}^\ast}` is greater than :math:`j`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is of the form :math:`{{\mathit{typeuse}}^\ast}{}[j]`. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{typeuse}}^\ast}~{\mathit{ct}})`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{none}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` :ref:`matches <match>` the heap type :math:`\mathsf{any}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is not of the form :math:`\mathsf{bot}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{nofunc}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` :ref:`matches <match>` the heap type :math:`\mathsf{func}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is not of the form :math:`\mathsf{bot}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{noexn}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` :ref:`matches <match>` the heap type :math:`\mathsf{exn}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is not of the form :math:`\mathsf{bot}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{noextern}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` :ref:`matches <match>` the heap type :math:`\mathsf{extern}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_2` is not of the form :math:`\mathsf{bot}`. |
| * Or: |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` is of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{heaptype}}` :ref:`matches <match>` only itself. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{heaptype}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}_2` if: |
| |
| |
| * The heap type :math:`{\mathit{heaptype}'}` is :ref:`valid <valid-val>`. |
| |
| * The heap type :math:`{\mathit{heaptype}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}'}`. |
| |
| * The heap type :math:`{\mathit{heaptype}'}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}_2`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{eq}` :ref:`matches <match>` the heap type :math:`\mathsf{any}`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{i{\scriptstyle 31}}` :ref:`matches <match>` the heap type :math:`\mathsf{eq}`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{struct}` :ref:`matches <match>` the heap type :math:`\mathsf{eq}`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{array}` :ref:`matches <match>` the heap type :math:`\mathsf{eq}`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{deftype}}` :ref:`matches <match>` the heap type :math:`\mathsf{struct}` if: |
| |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`(\mathsf{struct}~{{\mathit{fieldtype}}^\ast})`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{deftype}}` :ref:`matches <match>` the heap type :math:`\mathsf{array}` if: |
| |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`(\mathsf{array}~{\mathit{fieldtype}})`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{deftype}}` :ref:`matches <match>` the heap type :math:`\mathsf{func}` if: |
| |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{deftype}}` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{deftype}}_2` if: |
| |
| |
| * The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{typeidx}}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}`. |
| |
| |
| |
| |
| The heap type :math:`{\mathit{heaptype}}` :ref:`matches <match>` the heap type :math:`{\mathit{typeidx}}` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The heap type :math:`{\mathit{heaptype}}` :ref:`matches <match>` the type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]`. |
| |
| |
| |
| |
| The heap type :math:`(\mathsf{rec} {.} i)` :ref:`matches <match>` the heap type :math:`\mathsf{struct}` if: |
| |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~(\mathsf{struct}~{{\mathit{fieldtype}}^\ast}))`. |
| |
| |
| |
| |
| The heap type :math:`(\mathsf{rec} {.} i)` :ref:`matches <match>` the heap type :math:`\mathsf{array}` if: |
| |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~(\mathsf{array}~{\mathit{fieldtype}}))`. |
| |
| |
| |
| |
| The heap type :math:`(\mathsf{rec} {.} i)` :ref:`matches <match>` the heap type :math:`\mathsf{func}` if: |
| |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast}))`. |
| |
| |
| |
| |
| The heap type :math:`(\mathsf{rec} {.} i)` :ref:`matches <match>` the type use :math:`{{\mathit{typeuse}}^\ast}{}[j]` if: |
| |
| |
| * The length of :math:`{{\mathit{typeuse}}^\ast}` is greater than :math:`j`. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` exists. |
| |
| * The recursive type :math:`C{.}\mathsf{recs}{}[i]` is of the form :math:`(\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{typeuse}}^\ast}~{\mathit{ct}})`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{none}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}` if: |
| |
| |
| * The heap type :math:`{\mathit{heaptype}}` :ref:`matches <match>` the heap type :math:`\mathsf{any}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}` is not of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{nofunc}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}` if: |
| |
| |
| * The heap type :math:`{\mathit{heaptype}}` :ref:`matches <match>` the heap type :math:`\mathsf{func}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}` is not of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{noexn}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}` if: |
| |
| |
| * The heap type :math:`{\mathit{heaptype}}` :ref:`matches <match>` the heap type :math:`\mathsf{exn}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}` is not of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{noextern}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}` if: |
| |
| |
| * The heap type :math:`{\mathit{heaptype}}` :ref:`matches <match>` the heap type :math:`\mathsf{extern}`. |
| |
| * The heap type :math:`{\mathit{heaptype}}` is not of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The heap type :math:`\mathsf{bot}` :ref:`matches <match>` the heap type :math:`{\mathit{heaptype}}`. |
| |
| |
| |
| |
| The reference type :math:`(\mathsf{ref}~{{\mathsf{null}}_1^?}~{\mathit{ht}}_1)` :ref:`matches <match>` the reference type :math:`(\mathsf{ref}~{{\mathsf{null}}_2^?}~{\mathit{ht}}_2)` if: |
| |
| |
| * The heap type :math:`{\mathit{ht}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{ht}}_2`. |
| |
| * Either: |
| |
| * :math:`{{\mathsf{null}}_1^?}` is absent. |
| |
| * :math:`{{\mathsf{null}}_2^?}` is absent. |
| |
| * Or: |
| |
| * :math:`{{\mathsf{null}}_1^?}` is of the form :math:`{\mathsf{null}^?}`. |
| |
| * :math:`{{\mathsf{null}}_2^?}` is of the form :math:`\mathsf{null}`. |
| |
| |
| |
| |
| The reference type :math:`(\mathsf{ref}~{\mathit{ht}}_1)` :ref:`matches <match>` the reference type :math:`(\mathsf{ref}~{\mathit{ht}}_2)` if: |
| |
| |
| * The heap type :math:`{\mathit{ht}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{ht}}_2`. |
| |
| |
| |
| |
| The reference type :math:`(\mathsf{ref}~{\mathsf{null}^?}~{\mathit{ht}}_1)` :ref:`matches <match>` the reference type :math:`(\mathsf{ref}~\mathsf{null}~{\mathit{ht}}_2)` if: |
| |
| |
| * The heap type :math:`{\mathit{ht}}_1` :ref:`matches <match>` the heap type :math:`{\mathit{ht}}_2`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{valtype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_2` if: |
| |
| |
| * Either: |
| |
| * The value type :math:`{\mathit{valtype}}_1` is of the form :math:`{\mathit{numtype}}_1`. |
| |
| * The value type :math:`{\mathit{valtype}}_2` is of the form :math:`{\mathit{numtype}}_2`. |
| |
| * The number type :math:`{\mathit{numtype}}_1` :ref:`matches <match>` the number type :math:`{\mathit{numtype}}_2`. |
| |
| * Or: |
| |
| * The value type :math:`{\mathit{valtype}}_1` is of the form :math:`{\mathit{vectype}}_1`. |
| |
| * The value type :math:`{\mathit{valtype}}_2` is of the form :math:`{\mathit{vectype}}_2`. |
| |
| * The vector type :math:`{\mathit{vectype}}_1` :ref:`matches <match>` the vector type :math:`{\mathit{vectype}}_2`. |
| * Or: |
| |
| * The value type :math:`{\mathit{valtype}}_1` is of the form :math:`{\mathit{reftype}}_1`. |
| |
| * The value type :math:`{\mathit{valtype}}_2` is of the form :math:`{\mathit{reftype}}_2`. |
| |
| * The reference type :math:`{\mathit{reftype}}_1` :ref:`matches <match>` the reference type :math:`{\mathit{reftype}}_2`. |
| * Or: |
| |
| * The value type :math:`{\mathit{valtype}}_1` is of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{numtype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{numtype}}_2` if: |
| |
| |
| * The number type :math:`{\mathit{numtype}}_1` :ref:`matches <match>` the number type :math:`{\mathit{numtype}}_2`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{vectype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{vectype}}_2` if: |
| |
| |
| * The vector type :math:`{\mathit{vectype}}_1` :ref:`matches <match>` the vector type :math:`{\mathit{vectype}}_2`. |
| |
| |
| |
| |
| The value type :math:`{\mathit{reftype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{reftype}}_2` if: |
| |
| |
| * The reference type :math:`{\mathit{reftype}}_1` :ref:`matches <match>` the reference type :math:`{\mathit{reftype}}_2`. |
| |
| |
| |
| |
| The value type :math:`\mathsf{bot}` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}`. |
| |
| |
| |
| |
| The result type :math:`{t_1^\ast}` :ref:`matches <match>` the result type :math:`{t_2^\ast}` if: |
| |
| |
| * For all :math:`t_1` in :math:`{t_1^\ast}`, and corresponding :math:`t_2` in :math:`{t_2^\ast}`: |
| |
| * The value type :math:`t_1` :ref:`matches <match>` the value type :math:`t_2`. |
| |
| |
| |
| |
| The storage type :math:`{\mathit{storagetype}}_1` :ref:`matches <match>` the storage type :math:`{\mathit{storagetype}}_2` if: |
| |
| |
| * Either: |
| |
| * The storage type :math:`{\mathit{storagetype}}_1` is of the form :math:`{\mathit{valtype}}_1`. |
| |
| * The storage type :math:`{\mathit{storagetype}}_2` is of the form :math:`{\mathit{valtype}}_2`. |
| |
| * The value type :math:`{\mathit{valtype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_2`. |
| |
| * Or: |
| |
| * The storage type :math:`{\mathit{storagetype}}_1` is of the form :math:`{\mathit{packtype}}_1`. |
| |
| * The storage type :math:`{\mathit{storagetype}}_2` is of the form :math:`{\mathit{packtype}}_2`. |
| |
| * The packed type :math:`{\mathit{packtype}}_1` :ref:`matches <match>` the packed type :math:`{\mathit{packtype}}_2`. |
| |
| |
| |
| |
| The storage type :math:`{\mathit{valtype}}_1` :ref:`matches <match>` the storage type :math:`{\mathit{valtype}}_2` if: |
| |
| |
| * The value type :math:`{\mathit{valtype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_2`. |
| |
| |
| |
| |
| The storage type :math:`{\mathit{packtype}}_1` :ref:`matches <match>` the storage type :math:`{\mathit{packtype}}_2` if: |
| |
| |
| * The packed type :math:`{\mathit{packtype}}_1` :ref:`matches <match>` the packed type :math:`{\mathit{packtype}}_2`. |
| |
| |
| |
| |
| The field type :math:`({{\mathsf{mut}}_1^?}~{\mathit{zt}}_1)` :ref:`matches <match>` the field type :math:`({{\mathsf{mut}}_2^?}~{\mathit{zt}}_2)` if: |
| |
| |
| * The storage type :math:`{\mathit{zt}}_1` :ref:`matches <match>` the storage type :math:`{\mathit{zt}}_2`. |
| |
| * Either: |
| |
| * :math:`{{\mathsf{mut}}_1^?}` is absent. |
| |
| * :math:`{{\mathsf{mut}}_2^?}` is absent. |
| |
| * Or: |
| |
| * :math:`{{\mathsf{mut}}_1^?}` is of the form :math:`\mathsf{mut}`. |
| |
| * :math:`{{\mathsf{mut}}_2^?}` is of the form :math:`\mathsf{mut}`. |
| |
| * The storage type :math:`{\mathit{zt}}_2` :ref:`matches <match>` the storage type :math:`{\mathit{zt}}_1`. |
| |
| |
| |
| |
| The field type :math:`(\epsilon~{\mathit{zt}}_1)` :ref:`matches <match>` the field type :math:`(\epsilon~{\mathit{zt}}_2)` if: |
| |
| |
| * The storage type :math:`{\mathit{zt}}_1` :ref:`matches <match>` the storage type :math:`{\mathit{zt}}_2`. |
| |
| |
| |
| |
| The field type :math:`(\mathsf{mut}~{\mathit{zt}}_1)` :ref:`matches <match>` the field type :math:`(\mathsf{mut}~{\mathit{zt}}_2)` if: |
| |
| |
| * The storage type :math:`{\mathit{zt}}_1` :ref:`matches <match>` the storage type :math:`{\mathit{zt}}_2`. |
| |
| * The storage type :math:`{\mathit{zt}}_2` :ref:`matches <match>` the storage type :math:`{\mathit{zt}}_1`. |
| |
| |
| |
| |
| The local type :math:`({\mathit{init}}~t)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The value type :math:`t` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The result type :math:`{t_1^\ast}` is :ref:`valid <valid-val>`. |
| |
| * The result type :math:`{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`x` in :math:`{x^\ast}`: |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| |
| |
| |
| The sub type :math:`(\mathsf{sub}~{\mathsf{final}^?}~{x^\ast}~{\mathit{comptype}})` is :ref:`valid <valid-val>` for the type index :math:`x_0` if: |
| |
| |
| * The length of :math:`{x^\ast}` is less than or equal to :math:`1`. |
| |
| * For all :math:`x` in :math:`{x^\ast}`: |
| |
| * The index :math:`x` is less than :math:`x_0`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The sub type :math:`{\mathrm{unroll}}(C{.}\mathsf{types}{}[x])` is of the form :math:`(\mathsf{sub}~{y^\ast}~{\mathit{comptype}'})`. |
| |
| * :math:`{{\mathit{comptype}'}^\ast}` is the concatenation of all such :math:`{\mathit{comptype}'}`. |
| |
| * The composite type :math:`{\mathit{comptype}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{comptype}'}` in :math:`{{\mathit{comptype}'}^\ast}`: |
| |
| * The composite type :math:`{\mathit{comptype}}` :ref:`matches <match>` the composite type :math:`{\mathit{comptype}'}`. |
| |
| |
| |
| |
| The recursive type :math:`(\mathsf{rec}~{{\mathit{subtype}}^\ast})` is :ref:`valid <valid-val>` for the type index :math:`x` if: |
| |
| |
| * Either: |
| |
| * The sub type sequence :math:`{{\mathit{subtype}}^\ast}` is empty. |
| |
| * Or: |
| |
| * The sub type sequence :math:`{{\mathit{subtype}}^\ast}` is of the form :math:`{\mathit{subtype}}_1~{{\mathit{subtype}'}^\ast}`. |
| |
| * The sub type :math:`{\mathit{subtype}}_1` is :ref:`valid <valid-val>` for the type index :math:`x`. |
| |
| * The recursive type :math:`(\mathsf{rec}~{{\mathit{subtype}'}^\ast})` is :ref:`valid <valid-val>` for the type index :math:`x + 1`. |
| |
| |
| |
| |
| The recursive type :math:`(\mathsf{rec})` is :ref:`valid <valid-val>` for the type index :math:`x`. |
| |
| |
| |
| |
| The recursive type :math:`(\mathsf{rec}~{\mathit{subtype}}_1~{{\mathit{subtype}}^\ast})` is :ref:`valid <valid-val>` for the type index :math:`x` if: |
| |
| |
| * The sub type :math:`{\mathit{subtype}}_1` is :ref:`valid <valid-val>` for the type index :math:`x`. |
| |
| * The recursive type :math:`(\mathsf{rec}~{{\mathit{subtype}}^\ast})` is :ref:`valid <valid-val>` for the type index :math:`x + 1`. |
| |
| |
| |
| |
| The limits range :math:`{}[ n .. {m^?} ]` is :ref:`valid <valid-val>` within :math:`k` if: |
| |
| |
| * :math:`n` is less than or equal to :math:`k`. |
| |
| * If :math:`m` is defined, then: |
| |
| * :math:`n` is less than or equal to :math:`m`. |
| |
| * :math:`m` is less than or equal to :math:`k`. |
| |
| |
| |
| |
| The tag type :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The type use :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>`. |
| |
| * The :ref:`expansion <aux-expand-typeuse>` of :math:`C` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The global type :math:`({\mathsf{mut}^?}~t)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The value type :math:`t` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The memory type :math:`({\mathit{addrtype}}~{\mathit{limits}}~\mathsf{page})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The limits range :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` within :math:`{2^{{|{\mathit{addrtype}}|} - 16}}`. |
| |
| |
| |
| |
| The table type :math:`({\mathit{addrtype}}~{\mathit{limits}}~{\mathit{reftype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The limits range :math:`{\mathit{limits}}` is :ref:`valid <valid-val>` within :math:`{2^{{|{\mathit{addrtype}}|}}} - 1`. |
| |
| * The reference type :math:`{\mathit{reftype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`{\mathit{externtype}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{tag}~{\mathit{tagtype}})`. |
| |
| * The tag type :math:`{\mathit{tagtype}}` is :ref:`valid <valid-val>`. |
| |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{global}~{\mathit{globaltype}})`. |
| |
| * The global type :math:`{\mathit{globaltype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{mem}~{\mathit{memtype}})`. |
| |
| * The memory type :math:`{\mathit{memtype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{table}~{\mathit{tabletype}})`. |
| |
| * The table type :math:`{\mathit{tabletype}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{func}~{\mathit{typeuse}})`. |
| |
| * The type use :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>`. |
| |
| * The :ref:`expansion <aux-expand-typeuse>` of :math:`C` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{tag}~{\mathit{tagtype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The tag type :math:`{\mathit{tagtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{global}~{\mathit{globaltype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The global type :math:`{\mathit{globaltype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{mem}~{\mathit{memtype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The memory type :math:`{\mathit{memtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{table}~{\mathit{tabletype}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The table type :math:`{\mathit{tabletype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{func}~{\mathit{typeuse}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The type use :math:`{\mathit{typeuse}}` is :ref:`valid <valid-val>`. |
| |
| * The :ref:`expansion <aux-expand-typeuse>` of :math:`C` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The instruction type :math:`{t_{11}^\ast}~{\rightarrow}_{{x_1^\ast}}\,{t_{12}^\ast}` :ref:`matches <match>` the instruction type :math:`{t_{21}^\ast}~{\rightarrow}_{{x_2^\ast}}\,{t_{22}^\ast}` if: |
| |
| |
| * The result type :math:`{t_{21}^\ast}` :ref:`matches <match>` the result type :math:`{t_{11}^\ast}`. |
| |
| * The result type :math:`{t_{12}^\ast}` :ref:`matches <match>` the result type :math:`{t_{22}^\ast}`. |
| |
| * The local index sequence :math:`{x^\ast}` is of the form :math:`{x_2^\ast} \setminus {x_1^\ast}`. |
| |
| * For all :math:`x` in :math:`{x^\ast}`: |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`(\mathsf{set}~t)`. |
| |
| |
| |
| |
| The limits range :math:`{}[ n_1 .. {{\mathit{u{\kern-0.1em\scriptstyle 64}}}_1^?} ]` :ref:`matches <match>` the limits range :math:`{}[ n_2 .. {{\mathit{u{\kern-0.1em\scriptstyle 64}}}_2^?} ]` if: |
| |
| |
| * :math:`n_1` is greater than or equal to :math:`n_2`. |
| |
| * Either: |
| |
| * :math:`{{\mathit{u{\kern-0.1em\scriptstyle 64}}}_1^?}` is of the form :math:`m_1`. |
| |
| * If :math:`{\mathit{u{\kern-0.1em\scriptstyle 64}}}_2` is defined, then: |
| |
| * :math:`m_1` is less than or equal to :math:`{\mathit{u{\kern-0.1em\scriptstyle 64}}}_2`. |
| |
| * Or: |
| |
| * :math:`{{\mathit{u{\kern-0.1em\scriptstyle 64}}}_1^?}` is absent. |
| |
| * :math:`{{\mathit{u{\kern-0.1em\scriptstyle 64}}}_2^?}` is absent. |
| |
| |
| |
| |
| The limits range :math:`{}[ n_1 .. m_1 ]` :ref:`matches <match>` the limits range :math:`{}[ n_2 .. {m_2^?} ]` if: |
| |
| |
| * :math:`n_1` is greater than or equal to :math:`n_2`. |
| |
| * If :math:`m_2` is defined, then: |
| |
| * :math:`m_1` is less than or equal to :math:`m_2`. |
| |
| |
| |
| |
| The limits range :math:`{}[ n_1~.. ]` :ref:`matches <match>` the limits range :math:`{}[ n_2~.. ]` if: |
| |
| |
| * :math:`n_1` is greater than or equal to :math:`n_2`. |
| |
| |
| |
| |
| The tag type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the tag type :math:`{\mathit{deftype}}_2` if: |
| |
| |
| * The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2`. |
| |
| * The defined type :math:`{\mathit{deftype}}_2` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_1`. |
| |
| |
| |
| |
| The global type :math:`({{\mathsf{mut}}_1^?}~{\mathit{valtype}}_1)` :ref:`matches <match>` the global type :math:`({{\mathsf{mut}}_2^?}~{\mathit{valtype}}_2)` if: |
| |
| |
| * The value type :math:`{\mathit{valtype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_2`. |
| |
| * Either: |
| |
| * :math:`{{\mathsf{mut}}_1^?}` is absent. |
| |
| * :math:`{{\mathsf{mut}}_2^?}` is absent. |
| |
| * Or: |
| |
| * :math:`{{\mathsf{mut}}_1^?}` is of the form :math:`\mathsf{mut}`. |
| |
| * :math:`{{\mathsf{mut}}_2^?}` is of the form :math:`\mathsf{mut}`. |
| |
| * The value type :math:`{\mathit{valtype}}_2` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_1`. |
| |
| |
| |
| |
| The global type :math:`(\epsilon~{\mathit{valtype}}_1)` :ref:`matches <match>` the global type :math:`(\epsilon~{\mathit{valtype}}_2)` if: |
| |
| |
| * The value type :math:`{\mathit{valtype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_2`. |
| |
| |
| |
| |
| The global type :math:`(\mathsf{mut}~{\mathit{valtype}}_1)` :ref:`matches <match>` the global type :math:`(\mathsf{mut}~{\mathit{valtype}}_2)` if: |
| |
| |
| * The value type :math:`{\mathit{valtype}}_1` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_2`. |
| |
| * The value type :math:`{\mathit{valtype}}_2` :ref:`matches <match>` the value type :math:`{\mathit{valtype}}_1`. |
| |
| |
| |
| |
| The memory type :math:`({\mathit{addrtype}}~{\mathit{limits}}_1~\mathsf{page})` :ref:`matches <match>` the memory type :math:`({\mathit{addrtype}}~{\mathit{limits}}_2~\mathsf{page})` if: |
| |
| |
| * The limits range :math:`{\mathit{limits}}_1` :ref:`matches <match>` the limits range :math:`{\mathit{limits}}_2`. |
| |
| |
| |
| |
| The table type :math:`({\mathit{addrtype}}~{\mathit{limits}}_1~{\mathit{reftype}}_1)` :ref:`matches <match>` the table type :math:`({\mathit{addrtype}}~{\mathit{limits}}_2~{\mathit{reftype}}_2)` if: |
| |
| |
| * The limits range :math:`{\mathit{limits}}_1` :ref:`matches <match>` the limits range :math:`{\mathit{limits}}_2`. |
| |
| * The reference type :math:`{\mathit{reftype}}_1` :ref:`matches <match>` the reference type :math:`{\mathit{reftype}}_2`. |
| |
| * The reference type :math:`{\mathit{reftype}}_2` :ref:`matches <match>` the reference type :math:`{\mathit{reftype}}_1`. |
| |
| |
| |
| |
| The external type :math:`{\mathit{externtype}}_1` :ref:`matches <match>` the external type :math:`{\mathit{externtype}}_2` if: |
| |
| |
| * Either: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{tag}~{\mathit{tagtype}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{tag}~{\mathit{tagtype}}_2)`. |
| |
| * The tag type :math:`{\mathit{tagtype}}_1` :ref:`matches <match>` the tag type :math:`{\mathit{tagtype}}_2`. |
| |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{global}~{\mathit{globaltype}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{global}~{\mathit{globaltype}}_2)`. |
| |
| * The global type :math:`{\mathit{globaltype}}_1` :ref:`matches <match>` the global type :math:`{\mathit{globaltype}}_2`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{mem}~{\mathit{memtype}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{mem}~{\mathit{memtype}}_2)`. |
| |
| * The memory type :math:`{\mathit{memtype}}_1` :ref:`matches <match>` the memory type :math:`{\mathit{memtype}}_2`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{table}~{\mathit{tabletype}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{table}~{\mathit{tabletype}}_2)`. |
| |
| * The table type :math:`{\mathit{tabletype}}_1` :ref:`matches <match>` the table type :math:`{\mathit{tabletype}}_2`. |
| * Or: |
| |
| * The external type :math:`{\mathit{externtype}}_1` is of the form :math:`(\mathsf{func}~{\mathit{deftype}}_1)`. |
| |
| * The external type :math:`{\mathit{externtype}}_2` is of the form :math:`(\mathsf{func}~{\mathit{deftype}}_2)`. |
| |
| * The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{tag}~{\mathit{tagtype}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{tag}~{\mathit{tagtype}}_2)` if: |
| |
| |
| * The tag type :math:`{\mathit{tagtype}}_1` :ref:`matches <match>` the tag type :math:`{\mathit{tagtype}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{global}~{\mathit{globaltype}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{global}~{\mathit{globaltype}}_2)` if: |
| |
| |
| * The global type :math:`{\mathit{globaltype}}_1` :ref:`matches <match>` the global type :math:`{\mathit{globaltype}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{mem}~{\mathit{memtype}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{mem}~{\mathit{memtype}}_2)` if: |
| |
| |
| * The memory type :math:`{\mathit{memtype}}_1` :ref:`matches <match>` the memory type :math:`{\mathit{memtype}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{table}~{\mathit{tabletype}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{table}~{\mathit{tabletype}}_2)` if: |
| |
| |
| * The table type :math:`{\mathit{tabletype}}_1` :ref:`matches <match>` the table type :math:`{\mathit{tabletype}}_2`. |
| |
| |
| |
| |
| The external type :math:`(\mathsf{func}~{\mathit{deftype}}_1)` :ref:`matches <match>` the external type :math:`(\mathsf{func}~{\mathit{deftype}}_2)` if: |
| |
| |
| * The defined type :math:`{\mathit{deftype}}_1` :ref:`matches <match>` the defined type :math:`{\mathit{deftype}}_2`. |
| |
| |
| |
| |
| The block type :math:`{\mathit{blocktype}}` is :ref:`valid <valid-val>` as the instruction type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The block type :math:`{\mathit{blocktype}}` is of the form :math:`{{\mathit{valtype}''}^?}`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The value type sequence :math:`{{\mathit{valtype}'}^\ast}` is of the form :math:`{{\mathit{valtype}''}^?}`. |
| |
| * If :math:`{\mathit{valtype}''}` is defined, then: |
| |
| * The value type :math:`{\mathit{valtype}''}` is :ref:`valid <valid-val>`. |
| |
| * Or: |
| |
| * The block type :math:`{\mathit{blocktype}}` is of the form :math:`{\mathit{typeidx}}`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` is :math:`(\mathsf{func}~{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast})`. |
| |
| |
| |
| |
| The block type :math:`{{\mathit{valtype}}^?}` is :ref:`valid <valid-val>` as the instruction type :math:`\epsilon~\rightarrow~{{\mathit{valtype}}^?}` if: |
| |
| |
| * If :math:`{\mathit{valtype}}` is defined, then: |
| |
| * The value type :math:`{\mathit{valtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The block type :math:`{\mathit{typeidx}}` is :ref:`valid <valid-val>` as the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[{\mathit{typeidx}}]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The catch clause :math:`{\mathit{catch}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * Either: |
| |
| * The catch clause :math:`{\mathit{catch}}` is of the form :math:`(\mathsf{catch}~x~l)`. |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{tags}{}[x]` is :math:`(\mathsf{func}~{t^\ast}~\rightarrow)`. |
| |
| * The result type :math:`{t^\ast}` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| * Or: |
| |
| * The catch clause :math:`{\mathit{catch}}` is of the form :math:`(\mathsf{catch\_ref}~x~l)`. |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{tags}{}[x]` is :math:`(\mathsf{func}~{t^\ast}~\rightarrow)`. |
| |
| * The result type :math:`{t^\ast}~(\mathsf{ref}~\mathsf{exn})` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| * Or: |
| |
| * The catch clause :math:`{\mathit{catch}}` is of the form :math:`(\mathsf{catch\_all}~l)`. |
| |
| * The result type :math:`\epsilon` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| * Or: |
| |
| * The catch clause :math:`{\mathit{catch}}` is of the form :math:`(\mathsf{catch\_all\_ref}~l)`. |
| |
| * The result type :math:`(\mathsf{ref}~\mathsf{exn})` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| |
| |
| |
| The catch clause :math:`(\mathsf{catch}~x~l)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{tags}{}[x]` is :math:`(\mathsf{func}~{t^\ast}~\rightarrow)`. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`{t^\ast}` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| |
| |
| |
| The catch clause :math:`(\mathsf{catch\_ref}~x~l)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{tags}{}[x]` is :math:`(\mathsf{func}~{t^\ast}~\rightarrow)`. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`{t^\ast}~(\mathsf{ref}~\mathsf{exn})` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| |
| |
| |
| The catch clause :math:`(\mathsf{catch\_all}~l)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`\epsilon` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| |
| |
| |
| The catch clause :math:`(\mathsf{catch\_all\_ref}~l)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`(\mathsf{ref}~\mathsf{exn})` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| |
| |
| |
| The value type :math:`t` is defaultable if: |
| |
| |
| * The value :math:`{{\mathrm{default}}}_{t}` is present. |
| |
| |
| |
| |
| :math:`\{ \mathsf{align}~n,\;\allowbreak \mathsf{offset}~m \}` is valid for :math:`{\mathit{at}}` and :math:`N` if: |
| |
| |
| * :math:`{2^{n}}` is less than or equal to :math:`N / 8`. |
| |
| * :math:`m` is less than :math:`{2^{{|{\mathit{at}}|}}}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{nop}` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{unreachable}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{drop}` is :ref:`valid <valid-val>` with the instruction type :math:`t~\rightarrow~\epsilon` if: |
| |
| |
| * The value type :math:`t` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{select}~{{\mathit{valtype}}^?})` is :ref:`valid <valid-val>` with the instruction type :math:`t~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~t` if: |
| |
| |
| * The value type :math:`t` is :ref:`valid <valid-val>`. |
| |
| * Either: |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^?}` is of the form :math:`t`. |
| |
| * Or: |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^?}` is absent. |
| |
| * The value type :math:`t` :ref:`matches <match>` the value type :math:`{t'}`. |
| |
| * The value type :math:`{t'}` is of the form :math:`{\mathit{numtype}}` or :math:`{t'}` is of the form :math:`{\mathit{vectype}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{bt}}` is :ref:`valid <valid-val>` as the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_2^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{loop}~{\mathit{bt}}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{bt}}` is :ref:`valid <valid-val>` as the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_1^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{if}~{\mathit{bt}}~{{\mathit{instr}}_1^\ast}~\mathsf{else}~{{\mathit{instr}}_2^\ast})` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{bt}}` is :ref:`valid <valid-val>` as the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_2^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}_1^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}}\,{t_2^\ast}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x_2^\ast}}\,{t_2^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br}~l)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{t^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}`. |
| |
| * The instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_if}~l)` is :ref:`valid <valid-val>` with the instruction type :math:`{t^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t^\ast}` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_table}~{l^\ast}~{l'})` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{t^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * For all :math:`l` in :math:`{l^\ast}`: |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The result type :math:`{t^\ast}` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[l]`. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[{l'}]` exists. |
| |
| * The result type :math:`{t^\ast}` :ref:`matches <match>` the label :math:`C{.}\mathsf{labels}{}[{l'}]`. |
| |
| * The instruction type :math:`{t_1^\ast}~{t^\ast}~\mathsf{i{\scriptstyle 32}}~\rightarrow~{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_on\_null}~l)` is :ref:`valid <valid-val>` with the instruction type :math:`{t^\ast}~(\mathsf{ref}~\mathsf{null}~{\mathit{ht}})~\rightarrow~{t^\ast}~(\mathsf{ref}~{\mathit{ht}})` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}`. |
| |
| * The heap type :math:`{\mathit{ht}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_on\_non\_null}~l)` is :ref:`valid <valid-val>` with the instruction type :math:`{t^\ast}~(\mathsf{ref}~\mathsf{null}~{\mathit{ht}})~\rightarrow~{t^\ast}` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}~(\mathsf{ref}~{\mathsf{null}^?}~{\mathit{ht}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_on\_cast}~l~{\mathit{rt}}_1~{\mathit{rt}}_2)` is :ref:`valid <valid-val>` with the instruction type :math:`{t^\ast}~{\mathit{rt}}_1~\rightarrow~{t^\ast}~{\mathit{reftype}}` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}~{\mathit{rt}}`. |
| |
| * The reference type :math:`{\mathit{rt}}_1` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}}_2` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}}_2` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}_1`. |
| |
| * The reference type :math:`{\mathit{rt}}_2` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}`. |
| |
| * The reference type :math:`{\mathit{reftype}}` is :math:`{\mathit{rt}}_1 \setminus {\mathit{rt}}_2`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{br\_on\_cast\_fail}~l~{\mathit{rt}}_1~{\mathit{rt}}_2)` is :ref:`valid <valid-val>` with the instruction type :math:`{t^\ast}~{\mathit{rt}}_1~\rightarrow~{t^\ast}~{\mathit{rt}}_2` if: |
| |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` exists. |
| |
| * The label :math:`C{.}\mathsf{labels}{}[l]` is of the form :math:`{t^\ast}~{\mathit{rt}}`. |
| |
| * The reference type :math:`{\mathit{rt}}_1` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}}_2` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}}_2` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}_1`. |
| |
| * The reference type :math:`{\mathit{rt}}_1 \setminus {\mathit{rt}}_2` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{call}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{funcs}{}[x]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{call\_ref}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~(\mathsf{ref}~\mathsf{null}~x)~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{call\_indirect}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\mathit{at}}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| * The reference type :math:`{\mathit{rt}}` :ref:`matches <match>` the reference type :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{func})`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[y]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[y]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{return}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{t^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The result type :math:`C{.}\mathsf{return}` is of the form :math:`{t^\ast}`. |
| |
| * The instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{return\_call}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_3^\ast}~{t_1^\ast}~\rightarrow~{t_4^\ast}` if: |
| |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{funcs}{}[x]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| * The result type :math:`C{.}\mathsf{return}` is of the form :math:`{{t'}_2^\ast}`. |
| |
| * The result type :math:`{t_2^\ast}` :ref:`matches <match>` the result type :math:`{{t'}_2^\ast}`. |
| |
| * The instruction type :math:`{t_3^\ast}~\rightarrow~{t_4^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{return\_call\_ref}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_3^\ast}~{t_1^\ast}~(\mathsf{ref}~\mathsf{null}~x)~\rightarrow~{t_4^\ast}` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| * The result type :math:`C{.}\mathsf{return}` is of the form :math:`{{t'}_2^\ast}`. |
| |
| * The result type :math:`{t_2^\ast}` :ref:`matches <match>` the result type :math:`{{t'}_2^\ast}`. |
| |
| * The instruction type :math:`{t_3^\ast}~\rightarrow~{t_4^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{return\_call\_indirect}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_3^\ast}~{t_1^\ast}~{\mathit{at}}~\rightarrow~{t_4^\ast}` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| * The reference type :math:`{\mathit{rt}}` :ref:`matches <match>` the reference type :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{func})`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[y]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[y]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| * The result type :math:`C{.}\mathsf{return}` is of the form :math:`{{t'}_2^\ast}`. |
| |
| * The result type :math:`{t_2^\ast}` :ref:`matches <match>` the result type :math:`{{t'}_2^\ast}`. |
| |
| * The instruction type :math:`{t_3^\ast}~\rightarrow~{t_4^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{throw}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{t^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{tags}{}[x]` is :math:`(\mathsf{func}~{t^\ast}~\rightarrow)`. |
| |
| * The instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{throw\_ref}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~(\mathsf{ref}~\mathsf{null}~\mathsf{exn})~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{try\_table}~{\mathit{bt}}~{{\mathit{catch}}^\ast}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{bt}}` is :ref:`valid <valid-val>` as the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_2^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| * For all :math:`{\mathit{catch}}` in :math:`{{\mathit{catch}}^\ast}`: |
| |
| * The catch clause :math:`{\mathit{catch}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{ref{.}null}~{\mathit{ht}})` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~(\mathsf{ref}~\mathsf{null}~{\mathit{ht}})` if: |
| |
| |
| * The heap type :math:`{\mathit{ht}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{ref{.}func}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~(\mathsf{ref}~{\mathit{dt}})` if: |
| |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{\mathit{dt}}`. |
| |
| * :math:`x` is contained in :math:`C{.}\mathsf{refs}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{ref{.}i{\scriptstyle 31}}` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~(\mathsf{ref}~\mathsf{i{\scriptstyle 31}})`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{ref{.}is\_null}` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~{\mathit{ht}})~\rightarrow~\mathsf{i{\scriptstyle 32}}` if: |
| |
| |
| * The heap type :math:`{\mathit{ht}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{ref{.}as\_non\_null}` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~{\mathit{ht}})~\rightarrow~(\mathsf{ref}~{\mathit{ht}})` if: |
| |
| |
| * The heap type :math:`{\mathit{ht}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{ref{.}eq}` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{eq})~(\mathsf{ref}~\mathsf{null}~\mathsf{eq})~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{ref{.}test}~{\mathit{rt}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{rt}'}~\rightarrow~\mathsf{i{\scriptstyle 32}}` if: |
| |
| |
| * The reference type :math:`{\mathit{rt}}` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}'}` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}}` :ref:`matches <match>` the reference type :math:`{\mathit{rt}'}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{ref{.}cast}~{\mathit{rt}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{rt}'}~\rightarrow~{\mathit{rt}}` if: |
| |
| |
| * The reference type :math:`{\mathit{rt}}` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}'}` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}}` :ref:`matches <match>` the reference type :math:`{\mathit{rt}'}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{i{\scriptstyle 31}{.}get}}{\mathsf{\_}}{{\mathit{sx}}})` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{i{\scriptstyle 31}})~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{struct{.}new}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{t^\ast}~\rightarrow~(\mathsf{ref}~x)` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{struct}~{({\mathsf{mut}^?}~{\mathit{zt}})^\ast})`. |
| |
| * The value type sequence :math:`{t^\ast}` is :math:`{{\mathrm{unpack}}({\mathit{zt}})^\ast}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{struct{.}new\_default}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~(\mathsf{ref}~x)` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{struct}~{({\mathsf{mut}^?}~{\mathit{zt}})^\ast})`. |
| |
| * For all :math:`{\mathit{zt}}` in :math:`{{\mathit{zt}}^\ast}`: |
| |
| * A :ref:`default value <aux-default>` for :math:`{\mathrm{unpack}}({\mathit{zt}})` is defined. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{struct{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x~i)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x)~\rightarrow~t` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{struct}~{{\mathit{ft}}^\ast})`. |
| |
| * The length of :math:`{{\mathit{ft}}^\ast}` is greater than :math:`i`. |
| |
| * The field type :math:`{{\mathit{ft}}^\ast}{}[i]` is of the form :math:`({\mathsf{mut}^?}~{\mathit{zt}})`. |
| |
| * The signedness :math:`{{\mathit{sx}}^?}` is present if and only if :math:`{\mathit{zt}}` is a packed type. |
| |
| * The value type :math:`t` is :math:`{\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{struct{.}set}~x~i)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x)~t~\rightarrow~\epsilon` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{struct}~{{\mathit{ft}}^\ast})`. |
| |
| * The length of :math:`{{\mathit{ft}}^\ast}` is greater than :math:`i`. |
| |
| * The field type :math:`{{\mathit{ft}}^\ast}{}[i]` is of the form :math:`(\mathsf{mut}~{\mathit{zt}})`. |
| |
| * The value type :math:`t` is :math:`{\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}new}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`t~\mathsf{i{\scriptstyle 32}}~\rightarrow~(\mathsf{ref}~x)` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{zt}}))`. |
| |
| * The value type :math:`t` is :math:`{\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}new\_default}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{i{\scriptstyle 32}}~\rightarrow~(\mathsf{ref}~x)` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{zt}}))`. |
| |
| * A :ref:`default value <aux-default>` for :math:`{\mathrm{unpack}}({\mathit{zt}})` is defined. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}new\_fixed}~x~n)` is :ref:`valid <valid-val>` with the instruction type :math:`{t^{n}}~\rightarrow~(\mathsf{ref}~x)` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{zt}}))`. |
| |
| * The value type :math:`t` is :math:`{\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}new\_elem}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~(\mathsf{ref}~x)` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{rt}}))`. |
| |
| * The element segment :math:`C{.}\mathsf{elems}{}[y]` exists. |
| |
| * The element segment :math:`C{.}\mathsf{elems}{}[y]` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}new\_data}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~(\mathsf{ref}~x)` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{zt}}))`. |
| |
| * The value type :math:`{\mathrm{unpack}}({\mathit{zt}})` is of the form :math:`{\mathit{numtype}}` or :math:`{\mathrm{unpack}}({\mathit{zt}})` is of the form :math:`{\mathit{vectype}}`. |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[y]` exists. |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[y]` is of the form :math:`\mathsf{ok}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x)~\mathsf{i{\scriptstyle 32}}~\rightarrow~t` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{zt}}))`. |
| |
| * The signedness :math:`{{\mathit{sx}}^?}` is present if and only if :math:`{\mathit{zt}}` is a packed type. |
| |
| * The value type :math:`t` is :math:`{\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}set}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x)~\mathsf{i{\scriptstyle 32}}~t~\rightarrow~\epsilon` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~(\mathsf{mut}~{\mathit{zt}}))`. |
| |
| * The value type :math:`t` is :math:`{\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{array{.}len}` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{array})~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}fill}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x)~\mathsf{i{\scriptstyle 32}}~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~(\mathsf{mut}~{\mathit{zt}}))`. |
| |
| * The value type :math:`t` is :math:`{\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}copy}~x_1~x_2)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x_1)~\mathsf{i{\scriptstyle 32}}~(\mathsf{ref}~\mathsf{null}~x_2)~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x_1]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x_1]` is :math:`(\mathsf{array}~(\mathsf{mut}~{\mathit{zt}}_1))`. |
| |
| * The type :math:`C{.}\mathsf{types}{}[x_2]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x_2]` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{zt}}_2))`. |
| |
| * The storage type :math:`{\mathit{zt}}_2` :ref:`matches <match>` the storage type :math:`{\mathit{zt}}_1`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}init\_elem}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x)~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~(\mathsf{mut}~{\mathit{zt}}))`. |
| |
| * The element segment :math:`C{.}\mathsf{elems}{}[y]` exists. |
| |
| * The element segment :math:`C{.}\mathsf{elems}{}[y]` :ref:`matches <match>` the storage type :math:`{\mathit{zt}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{array{.}init\_data}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~\mathsf{null}~x)~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{array}~(\mathsf{mut}~{\mathit{zt}}))`. |
| |
| * The value type :math:`{\mathrm{unpack}}({\mathit{zt}})` is of the form :math:`{\mathit{numtype}}` or :math:`{\mathrm{unpack}}({\mathit{zt}})` is of the form :math:`{\mathit{vectype}}`. |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[y]` exists. |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[y]` is of the form :math:`\mathsf{ok}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{extern{.}convert\_any}` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~{{\mathsf{null}}_1^?}~\mathsf{any})~\rightarrow~(\mathsf{ref}~{{\mathsf{null}}_2^?}~\mathsf{extern})` if: |
| |
| |
| * :math:`{{\mathsf{null}}_1^?}` is of the form :math:`{{\mathsf{null}}_2^?}`. |
| |
| |
| |
| |
| The instruction :math:`\mathsf{any{.}convert\_extern}` is :ref:`valid <valid-val>` with the instruction type :math:`(\mathsf{ref}~{{\mathsf{null}}_1^?}~\mathsf{extern})~\rightarrow~(\mathsf{ref}~{{\mathsf{null}}_2^?}~\mathsf{any})` if: |
| |
| |
| * :math:`{{\mathsf{null}}_1^?}` is of the form :math:`{{\mathsf{null}}_2^?}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}get}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~t` if: |
| |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`(\mathsf{set}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}set}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`t~{\rightarrow}_{x}\,\epsilon` if: |
| |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`({\mathit{init}}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{local{.}tee}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`t~{\rightarrow}_{x}\,t` if: |
| |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x]` is of the form :math:`({\mathit{init}}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{global{.}get}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~t` if: |
| |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`({\mathsf{mut}^?}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{global{.}set}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`t~\rightarrow~\epsilon` if: |
| |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\mathsf{mut}~t)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}get}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~{\mathit{rt}}` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}set}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~{\mathit{rt}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}size}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~{\mathit{at}}` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}grow}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{rt}}~{\mathit{at}}~\rightarrow~{\mathit{at}}` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}fill}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~{\mathit{rt}}~{\mathit{at}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}copy}~x_1~x_2)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}_1~{\mathit{at}}_2~{\mathit{addrtype}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x_1]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x_1]` is of the form :math:`({\mathit{at}}_1~{\mathit{lim}}_1~{\mathit{rt}}_1)`. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x_2]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x_2]` is of the form :math:`({\mathit{at}}_2~{\mathit{lim}}_2~{\mathit{rt}}_2)`. |
| |
| * The reference type :math:`{\mathit{rt}}_2` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}_1`. |
| |
| * The address type :math:`{\mathit{addrtype}}` is :math:`{\mathrm{min}}({\mathit{at}}_1, {\mathit{at}}_2)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{table{.}init}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}}_1)`. |
| |
| * The element segment :math:`C{.}\mathsf{elems}{}[y]` exists. |
| |
| * The element segment :math:`C{.}\mathsf{elems}{}[y]` is of the form :math:`{\mathit{rt}}_2`. |
| |
| * The reference type :math:`{\mathit{rt}}_2` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}_1`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{elem{.}drop}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~\epsilon` if: |
| |
| |
| * The element segment :math:`C{.}\mathsf{elems}{}[x]` exists. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{memory{.}size}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~{\mathit{at}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{memory{.}grow}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~{\mathit{at}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{memory{.}fill}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\mathsf{i{\scriptstyle 32}}~{\mathit{at}}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{memory{.}copy}~x_1~x_2)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}_1~{\mathit{at}}_2~{\mathit{addrtype}}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x_1]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x_1]` is of the form :math:`({\mathit{at}}_1~{\mathit{lim}}_1~\mathsf{page})`. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x_2]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x_2]` is of the form :math:`({\mathit{at}}_2~{\mathit{lim}}_2~\mathsf{page})`. |
| |
| * The address type :math:`{\mathit{addrtype}}` is :math:`{\mathrm{min}}({\mathit{at}}_1, {\mathit{at}}_2)`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{memory{.}init}~x~y)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[y]` exists. |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[y]` is of the form :math:`\mathsf{ok}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{data{.}drop}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~\epsilon` if: |
| |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[x]` exists. |
| |
| * The data segment :math:`C{.}\mathsf{datas}{}[x]` is of the form :math:`\mathsf{ok}`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{nt}}{.}\mathsf{load}}{{{\mathit{loadop}}^?}}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~{\mathit{valtype}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * Either: |
| |
| * :math:`{{\mathit{loadop}}^?}` is absent. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{nt}}`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`{|{\mathit{nt}}|}`. |
| |
| * Or: |
| |
| * The number type :math:`{\mathit{nt}}` is of the form :math:`{\mathsf{i}}{N}`. |
| |
| * :math:`{{\mathit{loadop}}^?}` is of the form :math:`{K}{\mathsf{\_}}{{\mathit{sx}}}`. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathsf{i}}{N}`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`K`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{nt}}{.}\mathsf{store}}{{{\mathit{storeop}}^?}}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~{\mathit{valtype}}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * Either: |
| |
| * :math:`{{\mathit{storeop}}^?}` is absent. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{nt}}`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`{|{\mathit{nt}}|}`. |
| |
| * Or: |
| |
| * The number type :math:`{\mathit{nt}}` is of the form :math:`{\mathsf{i}}{N}`. |
| |
| * :math:`{{\mathit{storeop}}^?}` is of the form :math:`K`. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathsf{i}}{N}`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`K`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{{\mathit{vloadop}}^?}}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * Either: |
| |
| * :math:`{{\mathit{vloadop}}^?}` is absent. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`{|\mathsf{v{\scriptstyle 128}}|}`. |
| |
| * Or: |
| |
| * :math:`{{\mathit{vloadop}}^?}` is of the form :math:`({N}{\mathsf{x}}{M}{\mathsf{\_}}{{\mathit{sx}}})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N \cdot M`. |
| * Or: |
| |
| * :math:`{{\mathit{vloadop}}^?}` is of the form :math:`({N}{\mathsf{\_}}{\mathsf{splat}})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N`. |
| * Or: |
| |
| * :math:`{{\mathit{vloadop}}^?}` is of the form :math:`({N}{\mathsf{\_}}{\mathsf{zero}})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{N}{\mathsf{\_}}{\mathsf{lane}}~x~{\mathit{memarg}}~i)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N`. |
| |
| * :math:`i` is less than :math:`128 / N`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{store}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`{|\mathsf{v{\scriptstyle 128}}|}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{v{\scriptstyle 128}}{.}\mathsf{store}}{N}{\mathsf{\_}}{\mathsf{lane}}~x~{\mathit{memarg}}~i)` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N`. |
| |
| * :math:`i` is less than :math:`128 / N`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}{.}\mathsf{const}~c_{\mathit{nt}})` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~{\mathit{nt}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{unop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{nt}}~\rightarrow~{\mathit{nt}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{binop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{nt}}~{\mathit{nt}}~\rightarrow~{\mathit{nt}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{testop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{nt}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}} {.} {\mathit{relop}}_{\mathit{nt}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{nt}}~{\mathit{nt}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}_1 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{nt}}_2})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{nt}}_2~\rightarrow~{\mathit{nt}}_1`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvunop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvbinop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvternop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvtestop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vunop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vbinop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vternop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vtestop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vrelop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vshiftop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{bitmask})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}} {.} {\mathit{vswizzlop}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{shuffle}~{i^\ast})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * For all :math:`i` in :math:`{i^\ast}`: |
| |
| * The lane index :math:`i` is less than :math:`2 \cdot {\mathrm{dim}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{splat})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{numtype}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The number type :math:`{\mathit{numtype}}` is :math:`{\mathrm{unpack}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{sh}}{.}\mathsf{extract\_lane}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~i)` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~{\mathit{numtype}}` if: |
| |
| |
| * The lane index :math:`i` is less than :math:`{\mathrm{dim}}({\mathit{sh}})`. |
| |
| * The number type :math:`{\mathit{numtype}}` is :math:`{\mathrm{unpack}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}{.}\mathsf{replace\_lane}~i)` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~{\mathit{numtype}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The lane index :math:`i` is less than :math:`{\mathrm{dim}}({\mathit{sh}})`. |
| |
| * The number type :math:`{\mathit{numtype}}` is :math:`{\mathrm{unpack}}({\mathit{sh}})`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}_1 {.} {{\mathit{vextunop}}}{\mathsf{\_}}{{\mathit{sh}}_2})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}_1 {.} {{\mathit{vextbinop}}}{\mathsf{\_}}{{\mathit{sh}}_2})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}_1 {.} {{\mathit{vextternop}}}{\mathsf{\_}}{{\mathit{sh}}_2})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathit{sh}}_1{.}\mathsf{narrow}}{\mathsf{\_}}{{\mathit{sh}}_2}{\mathsf{\_}}{{\mathit{sx}}})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{sh}}_1 {.} {{\mathit{vcvtop}}}{\mathsf{\_}}{{\mathit{sh}}_2})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{v{\scriptstyle 128}}~\rightarrow~\mathsf{v{\scriptstyle 128}}`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{select}~t)` is :ref:`valid <valid-val>` with the instruction type :math:`t~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~t` if: |
| |
| |
| * The value type :math:`t` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{select})` is :ref:`valid <valid-val>` with the instruction type :math:`t~t~\mathsf{i{\scriptstyle 32}}~\rightarrow~t` if: |
| |
| |
| * The value type :math:`t` is :ref:`valid <valid-val>`. |
| |
| * The value type :math:`t` :ref:`matches <match>` the value type :math:`{t'}`. |
| |
| * The value type :math:`{t'}` is of the form :math:`{\mathit{numtype}}` or :math:`{t'}` is of the form :math:`{\mathit{vectype}}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}{.}\mathsf{load}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~{\mathit{nt}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`{|{\mathit{nt}}|}`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathsf{i}}{N}{.}\mathsf{load}}{{K}{\mathsf{\_}}{{\mathit{sx}}}}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~{\mathsf{i}}{N}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`K`. |
| |
| |
| |
| |
| The instruction :math:`({\mathit{nt}}{.}\mathsf{store}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~{\mathit{nt}}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`{|{\mathit{nt}}|}`. |
| |
| |
| |
| |
| The instruction :math:`({{\mathsf{i}}{N}{.}\mathsf{store}}{K}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~{\mathsf{i}}{N}~\rightarrow~\epsilon` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`K`. |
| |
| |
| |
| |
| The instruction :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`{|\mathsf{v{\scriptstyle 128}}|}`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{N}{\mathsf{x}}{M}{\mathsf{\_}}{{\mathit{sx}}}}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N \cdot M`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{N}{\mathsf{\_}}{\mathsf{splat}}}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N`. |
| |
| |
| |
| |
| The instruction :math:`({\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{N}{\mathsf{\_}}{\mathsf{zero}}}~x~{\mathit{memarg}})` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{at}}~\rightarrow~\mathsf{v{\scriptstyle 128}}` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * :math:`{\mathit{memarg}}` is valid for :math:`{\mathit{at}}` and :math:`N`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{it}}` if: |
| |
| |
| * Either: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is empty. |
| |
| * The instruction type :math:`{\mathit{it}}` is of the form :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| * Or: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is of the form :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}`. |
| |
| * The instruction type :math:`{\mathit{it}}` is of the form :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}~{x_2^\ast}}\,{t_3^\ast}`. |
| |
| * The instruction :math:`{\mathit{instr}}_1` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}}\,{t_2^\ast}`. |
| |
| * For all :math:`x_1` in :math:`{x_1^\ast}`: |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` is of the form :math:`({\mathit{init}}~t)`. |
| |
| * Under the context :math:`C` with the local types of :math:`{x_1^\ast}` updated to :math:`{(\mathsf{set}~t)^\ast}`, the instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_2^\ast}~{\rightarrow}_{{x_2^\ast}}\,{t_3^\ast}`. |
| * Or: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{it}''}`. |
| |
| * The instruction type :math:`{\mathit{it}''}` :ref:`matches <match>` the instruction type :math:`{\mathit{it}}`. |
| |
| * The instruction type :math:`{\mathit{it}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The instruction type :math:`{\mathit{it}}` is of the form :math:`{t^\ast}~{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t^\ast}~{t_2^\ast}`. |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| * The result type :math:`{t^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction sequence :math:`\epsilon` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| The instruction sequence :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}~{x_2^\ast}}\,{t_3^\ast}` if: |
| |
| |
| * The instruction :math:`{\mathit{instr}}_1` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}}\,{t_2^\ast}`. |
| |
| * For all :math:`x_1` in :math:`{x_1^\ast}`: |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` is of the form :math:`({\mathit{init}}~t)`. |
| |
| * :math:`{t^\ast}` is the concatenation of all such :math:`t`. |
| |
| * Under the context :math:`C` with the local types of :math:`{x_1^\ast}` updated to :math:`{(\mathsf{set}~t)^\ast}`, the instruction sequence :math:`{{\mathit{instr}}_2^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_2^\ast}~{\rightarrow}_{{x_2^\ast}}\,{t_3^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{it}}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{\mathit{it}'}`. |
| |
| * The instruction type :math:`{\mathit{it}'}` :ref:`matches <match>` the instruction type :math:`{\mathit{it}}`. |
| |
| * The instruction type :math:`{\mathit{it}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t^\ast}~{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t^\ast}~{t_2^\ast}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| * The result type :math:`{t^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The expression :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the result type :math:`{t^\ast}` if: |
| |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~{t^\ast}`. |
| |
| |
| |
| |
| The value type :math:`t` is not defaultable if: |
| |
| |
| * The value :math:`{{\mathrm{default}}}_{t}` is absent. |
| |
| |
| |
| |
| :math:`{\mathit{instr}}` is constant if: |
| |
| |
| * Either: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({\mathit{nt}}{.}\mathsf{const}~c_{\mathit{nt}})`. |
| |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({\mathit{vt}}{.}\mathsf{const}~c_{\mathit{vt}})`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{ref{.}null}~{\mathit{ht}})`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`\mathsf{ref{.}i{\scriptstyle 31}}`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{ref{.}func}~x)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{struct{.}new}~x)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{struct{.}new\_default}~x)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{array{.}new}~x)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{array{.}new\_default}~x)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{array{.}new\_fixed}~x~n)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`\mathsf{any{.}convert\_extern}`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`\mathsf{extern{.}convert\_any}`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{global{.}get}~x)`. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\epsilon~t)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({\mathsf{i}}{N} {.} {\mathit{binop}})`. |
| |
| * :math:`{\mathsf{i}}{N}` is contained in [:math:`\mathsf{i{\scriptstyle 32}}`; :math:`\mathsf{i{\scriptstyle 64}}`]. |
| |
| * :math:`{\mathit{binop}}` is contained in [:math:`\mathsf{add}`; :math:`\mathsf{sub}`; :math:`\mathsf{mul}`]. |
| |
| |
| |
| |
| :math:`({\mathit{nt}}{.}\mathsf{const}~c_{\mathit{nt}})` is constant. |
| |
| |
| |
| |
| :math:`({\mathit{vt}}{.}\mathsf{const}~c_{\mathit{vt}})` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{ref{.}null}~{\mathit{ht}})` is constant. |
| |
| |
| |
| |
| :math:`\mathsf{ref{.}i{\scriptstyle 31}}` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{ref{.}func}~x)` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{struct{.}new}~x)` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{struct{.}new\_default}~x)` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{array{.}new}~x)` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{array{.}new\_default}~x)` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{array{.}new\_fixed}~x~n)` is constant. |
| |
| |
| |
| |
| :math:`\mathsf{any{.}convert\_extern}` is constant. |
| |
| |
| |
| |
| :math:`\mathsf{extern{.}convert\_any}` is constant. |
| |
| |
| |
| |
| :math:`(\mathsf{global{.}get}~x)` is constant if: |
| |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\epsilon~t)`. |
| |
| |
| |
| |
| :math:`({\mathsf{i}}{N} {.} {\mathit{binop}})` is constant if: |
| |
| |
| * :math:`{\mathsf{i}}{N}` is contained in [:math:`\mathsf{i{\scriptstyle 32}}`; :math:`\mathsf{i{\scriptstyle 64}}`]. |
| |
| * :math:`{\mathit{binop}}` is contained in [:math:`\mathsf{add}`; :math:`\mathsf{sub}`; :math:`\mathsf{mul}`]. |
| |
| |
| |
| |
| :math:`{{\mathit{instr}}^\ast}` is constant if: |
| |
| |
| * For all :math:`{\mathit{instr}}` in :math:`{{\mathit{instr}}^\ast}`: |
| |
| * :math:`{\mathit{instr}}` is constant. |
| |
| |
| |
| |
| The type definition :math:`(\mathsf{type}~{\mathit{rectype}})` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{dt}}^\ast}` if: |
| |
| |
| * The length of :math:`C{.}\mathsf{types}` is equal to :math:`x`. |
| |
| * The defined type sequence :math:`{{\mathit{dt}}^\ast}` is of the form :math:`{{{{\mathrm{roll}}}_{x}^\ast}}{({\mathit{rectype}})}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the defined type sequence :math:`{{\mathit{dt}}^\ast}` appended to the field :math:`\mathsf{types}`. |
| |
| * Under the context :math:`{C'}`, the recursive type :math:`{\mathit{rectype}}` is :ref:`valid <valid-val>` for the type index :math:`x`. |
| |
| |
| |
| |
| The tag :math:`(\mathsf{tag}~{\mathit{tagtype}})` is :ref:`valid <valid-val>` with the tag type :math:`{\mathit{tagtype}'}` if: |
| |
| |
| * The tag type :math:`{\mathit{tagtype}}` is :ref:`valid <valid-val>`. |
| |
| * The tag type :math:`{\mathit{tagtype}'}` is :math:`{{\mathrm{clos}}}_{C}({\mathit{tagtype}})`. |
| |
| |
| |
| |
| The global :math:`(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}})` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{globaltype}}` if: |
| |
| |
| * The global type :math:`{\mathit{globaltype}}` is :ref:`valid <valid-val>`. |
| |
| * The global type :math:`{\mathit{globaltype}}` is of the form :math:`({\mathsf{mut}^?}~t)`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The memory :math:`(\mathsf{memory}~{\mathit{memtype}})` is :ref:`valid <valid-val>` with the memory type :math:`{\mathit{memtype}}` if: |
| |
| |
| * The memory type :math:`{\mathit{memtype}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The table :math:`(\mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}})` is :ref:`valid <valid-val>` with the table type :math:`{\mathit{tabletype}}` if: |
| |
| |
| * The table type :math:`{\mathit{tabletype}}` is :ref:`valid <valid-val>`. |
| |
| * The table type :math:`{\mathit{tabletype}}` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{rt}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The local :math:`(\mathsf{local}~t)` is :ref:`valid <valid-val>` with the local type :math:`({\mathit{init}}~t)` if: |
| |
| |
| * Either: |
| |
| * The initialization status :math:`{\mathit{init}}` is of the form :math:`\mathsf{set}`. |
| |
| * A :ref:`default value <aux-default>` for :math:`t` is defined. |
| |
| * Or: |
| |
| * The initialization status :math:`{\mathit{init}}` is of the form :math:`\mathsf{unset}`. |
| |
| * A :ref:`default value <aux-default>` for :math:`t` is not defined. |
| |
| |
| |
| |
| The local :math:`(\mathsf{local}~t)` is :ref:`valid <valid-val>` with the local type :math:`(\mathsf{set}~t)` if: |
| |
| |
| * A :ref:`default value <aux-default>` for :math:`t` is defined. |
| |
| |
| |
| |
| The local :math:`(\mathsf{local}~t)` is :ref:`valid <valid-val>` with the local type :math:`(\mathsf{unset}~t)` if: |
| |
| |
| * A :ref:`default value <aux-default>` for :math:`t` is not defined. |
| |
| |
| |
| |
| The function :math:`(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}})` is :ref:`valid <valid-val>` with the type :math:`C{.}\mathsf{types}{}[x]` if: |
| |
| |
| * The type :math:`C{.}\mathsf{types}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{types}{}[x]` is :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})`. |
| |
| * For all :math:`{\mathit{local}}` in :math:`{{\mathit{local}}^\ast}`: |
| |
| * The local :math:`{\mathit{local}}` is :ref:`valid <valid-val>` with the local type :math:`{{\mathit{lt}}}`. |
| |
| * :math:`{{{\mathit{lt}}}^\ast}` is the concatenation of all such :math:`{{\mathit{lt}}}`. |
| |
| * Under the context :math:`C` with the field :math:`\mathsf{locals}` appended by :math:`{(\mathsf{set}~t_1)^\ast}~{{{\mathit{lt}}}^\ast}` and the field :math:`\mathsf{labels}` appended by :math:`{t_2^\ast}` and the field :math:`\mathsf{return}` appended by :math:`{t_2^\ast}`, the expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the result type :math:`{t_2^\ast}`. |
| |
| |
| |
| |
| The data mode :math:`{\mathit{datamode}}` is :ref:`valid <valid-val>` if: |
| |
| |
| * Either: |
| |
| * The data mode :math:`{\mathit{datamode}}` is of the form :math:`\mathsf{passive}`. |
| |
| * Or: |
| |
| * The data mode :math:`{\mathit{datamode}}` is of the form :math:`(\mathsf{active}~x~{\mathit{expr}})`. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{at}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The data mode :math:`\mathsf{passive}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The data mode :math:`(\mathsf{active}~x~{\mathit{expr}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{at}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The memory segment :math:`(\mathsf{data}~{b^\ast}~{\mathit{datamode}})` is :ref:`valid <valid-val>` if: |
| |
| |
| * The data mode :math:`{\mathit{datamode}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The element mode :math:`{\mathit{elemmode}}` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{rt}}` if: |
| |
| |
| * Either: |
| |
| * The element mode :math:`{\mathit{elemmode}}` is of the form :math:`\mathsf{passive}`. |
| |
| * Or: |
| |
| * The element mode :math:`{\mathit{elemmode}}` is of the form :math:`\mathsf{declare}`. |
| * Or: |
| |
| * The element mode :math:`{\mathit{elemmode}}` is of the form :math:`(\mathsf{active}~x~{\mathit{expr}})`. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}'})`. |
| |
| * The reference type :math:`{\mathit{rt}}` :ref:`matches <match>` the reference type :math:`{\mathit{rt}'}`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{at}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The element mode :math:`\mathsf{passive}` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The element mode :math:`\mathsf{declare}` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The element mode :math:`(\mathsf{active}~x~{\mathit{expr}})` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{rt}}` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}'})`. |
| |
| * The reference type :math:`{\mathit{rt}}` :ref:`matches <match>` the reference type :math:`{\mathit{rt}'}`. |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{at}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| |
| |
| |
| The table segment :math:`(\mathsf{elem}~{\mathit{elemtype}}~{{\mathit{expr}}^\ast}~{\mathit{elemmode}})` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{elemtype}}` if: |
| |
| |
| * The reference type :math:`{\mathit{elemtype}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{expr}}` in :math:`{{\mathit{expr}}^\ast}`: |
| |
| * The expression :math:`{\mathit{expr}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{elemtype}}`. |
| |
| * :math:`{\mathit{expr}}` is constant. |
| |
| * The element mode :math:`{\mathit{elemmode}}` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{elemtype}}`. |
| |
| |
| |
| |
| The start function :math:`(\mathsf{start}~x)` is :ref:`valid <valid-val>` if: |
| |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`C{.}\mathsf{funcs}{}[x]` is :math:`(\mathsf{func}~\rightarrow)`. |
| |
| |
| |
| |
| The import :math:`(\mathsf{import}~{\mathit{name}}_1~{\mathit{name}}_2~{\mathit{xt}})` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{externtype}}` if: |
| |
| |
| * The external type :math:`{\mathit{xt}}` is :ref:`valid <valid-val>`. |
| |
| * The external type :math:`{\mathit{externtype}}` is :math:`{{\mathrm{clos}}}_{C}({\mathit{xt}})`. |
| |
| |
| |
| |
| The external index :math:`{\mathit{externidx}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{externtype}}` if: |
| |
| |
| * Either: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{tag}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{tag}~{\mathit{jt}})`. |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` exists. |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` is of the form :math:`{\mathit{jt}}`. |
| |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{global}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{global}~{\mathit{gt}})`. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`{\mathit{gt}}`. |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{mem}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{mem}~{\mathit{mt}})`. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`{\mathit{mt}}`. |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{table}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{table}~{\mathit{tt}})`. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`{\mathit{tt}}`. |
| * Or: |
| |
| * The external index :math:`{\mathit{externidx}}` is of the form :math:`(\mathsf{func}~x)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{func}~{\mathit{dt}})`. |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{\mathit{dt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{tag}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{tag}~{\mathit{jt}})` if: |
| |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` exists. |
| |
| * The tag :math:`C{.}\mathsf{tags}{}[x]` is of the form :math:`{\mathit{jt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{global}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{global}~{\mathit{gt}})` if: |
| |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`{\mathit{gt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{mem}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{mem}~{\mathit{mt}})` if: |
| |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` exists. |
| |
| * The memory :math:`C{.}\mathsf{mems}{}[x]` is of the form :math:`{\mathit{mt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{table}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{table}~{\mathit{tt}})` if: |
| |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` exists. |
| |
| * The table :math:`C{.}\mathsf{tables}{}[x]` is of the form :math:`{\mathit{tt}}`. |
| |
| |
| |
| |
| The external index :math:`(\mathsf{func}~x)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{func}~{\mathit{dt}})` if: |
| |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` exists. |
| |
| * The function :math:`C{.}\mathsf{funcs}{}[x]` is of the form :math:`{\mathit{dt}}`. |
| |
| |
| |
| |
| The export :math:`(\mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` is :ref:`valid <valid-val>` with the name :math:`{\mathit{name}}` and the external type :math:`{\mathit{xt}}` if: |
| |
| |
| * The external index :math:`{\mathit{externidx}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}`. |
| |
| |
| |
| |
| The global sequence :math:`{{\mathit{global}}^\ast}` is :ref:`valid <valid-val>` with the global type sequence :math:`{{\mathit{globaltype}}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The global sequence :math:`{{\mathit{global}}^\ast}` is empty. |
| |
| * The global type sequence :math:`{{\mathit{globaltype}}^\ast}` is empty. |
| |
| * Or: |
| |
| * The global sequence :math:`{{\mathit{global}}^\ast}` is of the form :math:`{\mathit{global}}_1~{{\mathit{global}'}^\ast}`. |
| |
| * The global type sequence :math:`{{\mathit{globaltype}}^\ast}` is of the form :math:`{\mathit{gt}}_1~{{\mathit{gt}}^\ast}`. |
| |
| * The global :math:`{\mathit{global}}_1` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{gt}}_1`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the global type sequence :math:`{\mathit{gt}}_1` appended to the field :math:`\mathsf{globals}`. |
| |
| * Under the context :math:`{C'}`, the global sequence :math:`{{\mathit{global}'}^\ast}` is :ref:`valid <valid-val>` with the global type sequence :math:`{{\mathit{gt}}^\ast}`. |
| |
| |
| |
| |
| The global sequence :math:`\epsilon` is :ref:`valid <valid-val>` with the global type sequence :math:`\epsilon`. |
| |
| |
| |
| |
| The global sequence :math:`{\mathit{global}}_1~{{\mathit{global}}^\ast}` is :ref:`valid <valid-val>` with the global type sequence :math:`{\mathit{gt}}_1~{{\mathit{gt}}^\ast}` if: |
| |
| |
| * The global :math:`{\mathit{global}}_1` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{gt}}_1`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the global type sequence :math:`{\mathit{gt}}_1` appended to the field :math:`\mathsf{globals}`. |
| |
| * Under the context :math:`{C'}`, the global sequence :math:`{{\mathit{global}}^\ast}` is :ref:`valid <valid-val>` with the global type sequence :math:`{{\mathit{gt}}^\ast}`. |
| |
| |
| |
| |
| The type definition sequence :math:`{{\mathit{type}}^\ast}` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{deftype}}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The type definition sequence :math:`{{\mathit{type}}^\ast}` is empty. |
| |
| * The defined type sequence :math:`{{\mathit{deftype}}^\ast}` is empty. |
| |
| * Or: |
| |
| * The type definition sequence :math:`{{\mathit{type}}^\ast}` is of the form :math:`{\mathit{type}}_1~{{\mathit{type}'}^\ast}`. |
| |
| * The defined type sequence :math:`{{\mathit{deftype}}^\ast}` is of the form :math:`{{\mathit{dt}}_1^\ast}~{{\mathit{dt}}^\ast}`. |
| |
| * The type definition :math:`{\mathit{type}}_1` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{dt}}_1^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the defined type sequence :math:`{{\mathit{dt}}_1^\ast}` appended to the field :math:`\mathsf{types}`. |
| |
| * Under the context :math:`{C'}`, the type definition sequence :math:`{{\mathit{type}'}^\ast}` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{dt}}^\ast}`. |
| |
| |
| |
| |
| The type definition sequence :math:`\epsilon` is :ref:`valid <valid-val>` with the defined type sequence :math:`\epsilon`. |
| |
| |
| |
| |
| The type definition sequence :math:`{\mathit{type}}_1~{{\mathit{type}}^\ast}` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{dt}}_1^\ast}~{{\mathit{dt}}^\ast}` if: |
| |
| |
| * The type definition :math:`{\mathit{type}}_1` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{dt}}_1^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the defined type sequence :math:`{{\mathit{dt}}_1^\ast}` appended to the field :math:`\mathsf{types}`. |
| |
| * Under the context :math:`{C'}`, the type definition sequence :math:`{{\mathit{type}}^\ast}` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{dt}}^\ast}`. |
| |
| |
| |
| |
| The module :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` is :ref:`valid <valid-val>` with the module type :math:`{\mathit{moduletype}}` if: |
| |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the type definition sequence :math:`{{\mathit{type}}^\ast}` is :ref:`valid <valid-val>` with the defined type sequence :math:`{{\mathit{dt}'}^\ast}`. |
| |
| * For all :math:`{\mathit{import}}` in :math:`{{\mathit{import}}^\ast}`: |
| |
| * Under the context :math:`\{ \mathsf{types}~{{\mathit{dt}'}^\ast},\;\allowbreak \mathsf{return}~\epsilon \}`, the import :math:`{\mathit{import}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}_{\mathsf{i}}`. |
| |
| * :math:`{{\mathit{xt}}_{\mathsf{i}}^\ast}` is the concatenation of all such :math:`{\mathit{xt}}_{\mathsf{i}}`. |
| |
| * For all :math:`{\mathit{tag}}` in :math:`{{\mathit{tag}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the tag :math:`{\mathit{tag}}` is :ref:`valid <valid-val>` with the tag type :math:`{\mathit{jt}}`. |
| |
| * :math:`{{\mathit{jt}}^\ast}` is the concatenation of all such :math:`{\mathit{jt}}`. |
| |
| * Under the context :math:`{C'}`, the global sequence :math:`{{\mathit{global}}^\ast}` is :ref:`valid <valid-val>` with the global type sequence :math:`{{\mathit{gt}}^\ast}`. |
| |
| * For all :math:`{\mathit{mem}}` in :math:`{{\mathit{mem}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the memory :math:`{\mathit{mem}}` is :ref:`valid <valid-val>` with the memory type :math:`{\mathit{mt}}`. |
| |
| * :math:`{{\mathit{mt}}^\ast}` is the concatenation of all such :math:`{\mathit{mt}}`. |
| |
| * For all :math:`{\mathit{table}}` in :math:`{{\mathit{table}}^\ast}`: |
| |
| * Under the context :math:`{C'}`, the table :math:`{\mathit{table}}` is :ref:`valid <valid-val>` with the table type :math:`{\mathit{tt}}`. |
| |
| * :math:`{{\mathit{tt}}^\ast}` is the concatenation of all such :math:`{\mathit{tt}}`. |
| |
| * For all :math:`{\mathit{func}}` in :math:`{{\mathit{func}}^\ast}`: |
| |
| * The function :math:`{\mathit{func}}` is :ref:`valid <valid-val>` with the defined type :math:`{\mathit{dt}}`. |
| |
| * :math:`{{\mathit{dt}}^\ast}` is the concatenation of all such :math:`{\mathit{dt}}`. |
| |
| * For all :math:`{\mathit{data}}` in :math:`{{\mathit{data}}^\ast}`: |
| |
| * The memory segment :math:`{\mathit{data}}` is :ref:`valid <valid-val>`. |
| |
| * :math:`{{\mathit{ok}}^\ast}` is the concatenation of all such :math:`{\mathit{ok}}`. |
| |
| * For all :math:`{\mathit{elem}}` in :math:`{{\mathit{elem}}^\ast}`: |
| |
| * The table segment :math:`{\mathit{elem}}` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{rt}}`. |
| |
| * :math:`{{\mathit{rt}}^\ast}` is the concatenation of all such :math:`{\mathit{rt}}`. |
| |
| * If :math:`{\mathit{start}}` is defined, then: |
| |
| * The start function :math:`{\mathit{start}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{export}}` in :math:`{{\mathit{export}}^\ast}`: |
| |
| * The export :math:`{\mathit{export}}` is :ref:`valid <valid-val>` with the name :math:`{\mathit{nm}}` and the external type :math:`{\mathit{xt}}_{\mathsf{e}}`. |
| |
| * :math:`{{\mathit{nm}}^\ast}` is the concatenation of all such :math:`{\mathit{nm}}`. |
| |
| * :math:`{{\mathit{xt}}_{\mathsf{e}}^\ast}` is the concatenation of all such :math:`{\mathit{xt}}_{\mathsf{e}}`. |
| |
| * :math:`{{\mathit{nm}}^\ast}~{\mathrm{disjoint}}` is true. |
| |
| * The context :math:`C` is of the form :math:`{C'}` with the field :math:`\mathsf{tags}` appended by :math:`{{\mathit{jt}}_{\mathsf{i}}^\ast}~{{\mathit{jt}}^\ast}` and the field :math:`\mathsf{globals}` appended by :math:`{{\mathit{gt}}^\ast}` and the field :math:`\mathsf{mems}` appended by :math:`{{\mathit{mt}}_{\mathsf{i}}^\ast}~{{\mathit{mt}}^\ast}` and the field :math:`\mathsf{tables}` appended by :math:`{{\mathit{tt}}_{\mathsf{i}}^\ast}~{{\mathit{tt}}^\ast}` and the field :math:`\mathsf{datas}` appended by :math:`{{\mathit{ok}}^\ast}` and the field :math:`\mathsf{elems}` appended by :math:`{{\mathit{rt}}^\ast}`. |
| |
| * The context :math:`{C'}` is of the form :math:`\{ \mathsf{types}~{{\mathit{dt}'}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\;\allowbreak \mathsf{return}~\epsilon,\;\allowbreak \mathsf{refs}~{x^\ast} \}`. |
| |
| * The function index sequence :math:`{x^\ast}` is of the form :math:`{\mathrm{funcidx}}({{\mathit{global}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})`. |
| |
| * The tag type sequence :math:`{{\mathit{jt}}_{\mathsf{i}}^\ast}` is of the form :math:`{\mathrm{tags}}({{\mathit{xt}}_{\mathsf{i}}^\ast})`. |
| |
| * The global type sequence :math:`{{\mathit{gt}}_{\mathsf{i}}^\ast}` is of the form :math:`{\mathrm{globals}}({{\mathit{xt}}_{\mathsf{i}}^\ast})`. |
| |
| * The memory type sequence :math:`{{\mathit{mt}}_{\mathsf{i}}^\ast}` is of the form :math:`{\mathrm{mems}}({{\mathit{xt}}_{\mathsf{i}}^\ast})`. |
| |
| * The table type sequence :math:`{{\mathit{tt}}_{\mathsf{i}}^\ast}` is of the form :math:`{\mathrm{tables}}({{\mathit{xt}}_{\mathsf{i}}^\ast})`. |
| |
| * The defined type sequence :math:`{{\mathit{dt}}_{\mathsf{i}}^\ast}` is of the form :math:`{\mathrm{funcs}}({{\mathit{xt}}_{\mathsf{i}}^\ast})`. |
| |
| * The module type :math:`{\mathit{moduletype}}` is :math:`{{\mathrm{clos}}}_{C}({{\mathit{xt}}_{\mathsf{i}}^\ast}~\rightarrow~{{\mathit{xt}}_{\mathsf{e}}^\ast})`. |
| |
| |
| |
| |
| The number value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` is :ref:`valid <valid-val>` with the number type :math:`{\mathit{nt}}`. |
| |
| |
| |
| |
| The vector value :math:`({\mathit{vt}}{.}\mathsf{const}~c)` is :ref:`valid <valid-val>` with the vector type :math:`{\mathit{vt}}`. |
| |
| |
| |
| |
| The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}` if: |
| |
| |
| * Either: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`\mathsf{ref{.}null}`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{bot})`. |
| |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`(\mathsf{ref{.}i{\scriptstyle 31}}~i)`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~\mathsf{i{\scriptstyle 31}})`. |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`(\mathsf{ref{.}struct}~a)`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~{\mathit{dt}})`. |
| |
| * The structure instance :math:`s{.}\mathsf{structs}{}[a]` exists. |
| |
| * The defined type :math:`s{.}\mathsf{structs}{}[a]{.}\mathsf{type}` is of the form :math:`{\mathit{dt}}`. |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`(\mathsf{ref{.}array}~a)`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~{\mathit{dt}})`. |
| |
| * The array instance :math:`s{.}\mathsf{arrays}{}[a]` exists. |
| |
| * The defined type :math:`s{.}\mathsf{arrays}{}[a]{.}\mathsf{type}` is of the form :math:`{\mathit{dt}}`. |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`(\mathsf{ref{.}func}~a)`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~{\mathit{dt}})`. |
| |
| * The function instance :math:`s{.}\mathsf{funcs}{}[a]` exists. |
| |
| * The defined type :math:`s{.}\mathsf{funcs}{}[a]{.}\mathsf{type}` is of the form :math:`{\mathit{dt}}`. |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`(\mathsf{ref{.}exn}~a)`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~\mathsf{exn})`. |
| |
| * The exception instance :math:`s{.}\mathsf{exns}{}[a]` exists. |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`(\mathsf{ref{.}host}~a)`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~\mathsf{any})`. |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is of the form :math:`(\mathsf{ref{.}extern}~{\mathit{ref}'})`. |
| |
| * The reference type :math:`{\mathit{rt}}` is of the form :math:`(\mathsf{ref}~\mathsf{extern})`. |
| |
| * The reference value :math:`{\mathit{ref}'}` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~\mathsf{any})`. |
| |
| * The reference value :math:`{\mathit{ref}'}` is not of the form :math:`\mathsf{ref{.}null}`. |
| * Or: |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}'}`. |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the reference type :math:`{\mathit{rt}}` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}'}` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The reference value :math:`\mathsf{ref{.}null}` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{bot})`. |
| |
| |
| |
| |
| The reference value :math:`(\mathsf{ref{.}i{\scriptstyle 31}}~i)` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~\mathsf{i{\scriptstyle 31}})`. |
| |
| |
| |
| |
| The reference value :math:`(\mathsf{ref{.}struct}~a)` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~{\mathit{dt}})` if: |
| |
| |
| * The structure instance :math:`s{.}\mathsf{structs}{}[a]` exists. |
| |
| * The defined type :math:`s{.}\mathsf{structs}{}[a]{.}\mathsf{type}` is of the form :math:`{\mathit{dt}}`. |
| |
| |
| |
| |
| The reference value :math:`(\mathsf{ref{.}array}~a)` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~{\mathit{dt}})` if: |
| |
| |
| * The array instance :math:`s{.}\mathsf{arrays}{}[a]` exists. |
| |
| * The defined type :math:`s{.}\mathsf{arrays}{}[a]{.}\mathsf{type}` is of the form :math:`{\mathit{dt}}`. |
| |
| |
| |
| |
| The reference value :math:`(\mathsf{ref{.}func}~a)` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~{\mathit{dt}})` if: |
| |
| |
| * The function instance :math:`s{.}\mathsf{funcs}{}[a]` exists. |
| |
| * The defined type :math:`s{.}\mathsf{funcs}{}[a]{.}\mathsf{type}` is of the form :math:`{\mathit{dt}}`. |
| |
| |
| |
| |
| The reference value :math:`(\mathsf{ref{.}exn}~a)` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~\mathsf{exn})` if: |
| |
| |
| * The exception instance :math:`s{.}\mathsf{exns}{}[a]` exists. |
| |
| |
| |
| |
| The reference value :math:`(\mathsf{ref{.}host}~a)` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~\mathsf{any})`. |
| |
| |
| |
| |
| The reference value :math:`(\mathsf{ref{.}extern}~{\mathit{ref}})` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~\mathsf{extern})` if: |
| |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`(\mathsf{ref}~\mathsf{any})`. |
| |
| * The reference value :math:`{\mathit{ref}}` is not of the form :math:`\mathsf{ref{.}null}`. |
| |
| |
| |
| |
| The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}` if: |
| |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}'}`. |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the reference type :math:`{\mathit{rt}}` is :ref:`valid <valid-val>`. |
| |
| * The reference type :math:`{\mathit{rt}'}` :ref:`matches <match>` the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{valtype}}` if: |
| |
| |
| * Either: |
| |
| * The value :math:`{\mathit{val}}` is of the form :math:`{\mathit{num}}`. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{nt}}`. |
| |
| * The number value :math:`{\mathit{num}}` is :ref:`valid <valid-val>` with the number type :math:`{\mathit{nt}}`. |
| |
| * Or: |
| |
| * The value :math:`{\mathit{val}}` is of the form :math:`{\mathit{vec}}`. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{vt}}`. |
| |
| * The vector value :math:`{\mathit{vec}}` is :ref:`valid <valid-val>` with the vector type :math:`{\mathit{vt}}`. |
| * Or: |
| |
| * The value :math:`{\mathit{val}}` is of the form :math:`{\mathit{ref}}`. |
| |
| * The value type :math:`{\mathit{valtype}}` is of the form :math:`{\mathit{rt}}`. |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The value :math:`{\mathit{num}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{nt}}` if: |
| |
| |
| * The number value :math:`{\mathit{num}}` is :ref:`valid <valid-val>` with the number type :math:`{\mathit{nt}}`. |
| |
| |
| |
| |
| The value :math:`{\mathit{vec}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{vt}}` if: |
| |
| |
| * The vector value :math:`{\mathit{vec}}` is :ref:`valid <valid-val>` with the vector type :math:`{\mathit{vt}}`. |
| |
| |
| |
| |
| The value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the value type :math:`{\mathit{rt}}` if: |
| |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The packed value :math:`({\mathit{pt}}{.}\mathsf{pack}~c)` is :ref:`valid <valid-val>` with the packed type :math:`{\mathit{pt}}`. |
| |
| |
| |
| |
| The field value :math:`{\mathit{fieldval}}` is :ref:`valid <valid-val>` with the storage type :math:`{\mathit{storagetype}}` if: |
| |
| |
| * Either: |
| |
| * The field value :math:`{\mathit{fieldval}}` is of the form :math:`{\mathit{val}}`. |
| |
| * The storage type :math:`{\mathit{storagetype}}` is of the form :math:`t`. |
| |
| * The value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| * Or: |
| |
| * The field value :math:`{\mathit{fieldval}}` is of the form :math:`{\mathit{packval}}`. |
| |
| * The storage type :math:`{\mathit{storagetype}}` is of the form :math:`{\mathit{pt}}`. |
| |
| * The packed value :math:`{\mathit{packval}}` is :ref:`valid <valid-val>` with the packed type :math:`{\mathit{pt}}`. |
| |
| |
| |
| |
| The field value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the storage type :math:`t` if: |
| |
| |
| * The value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| |
| |
| |
| The field value :math:`{\mathit{packval}}` is :ref:`valid <valid-val>` with the storage type :math:`{\mathit{pt}}` if: |
| |
| |
| * The packed value :math:`{\mathit{packval}}` is :ref:`valid <valid-val>` with the packed type :math:`{\mathit{pt}}`. |
| |
| |
| |
| |
| The external address :math:`{\mathit{externaddr}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{externtype}}` if: |
| |
| |
| * Either: |
| |
| * The external address :math:`{\mathit{externaddr}}` is of the form :math:`(\mathsf{tag}~a)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{tag}~{\mathit{taginst}}{.}\mathsf{type})`. |
| |
| * The tag instance :math:`s{.}\mathsf{tags}{}[a]` exists. |
| |
| * The tag instance :math:`s{.}\mathsf{tags}{}[a]` is of the form :math:`{\mathit{taginst}}`. |
| |
| * Or: |
| |
| * The external address :math:`{\mathit{externaddr}}` is of the form :math:`(\mathsf{global}~a)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{global}~{\mathit{globalinst}}{.}\mathsf{type})`. |
| |
| * The global instance :math:`s{.}\mathsf{globals}{}[a]` exists. |
| |
| * The global instance :math:`s{.}\mathsf{globals}{}[a]` is of the form :math:`{\mathit{globalinst}}`. |
| * Or: |
| |
| * The external address :math:`{\mathit{externaddr}}` is of the form :math:`(\mathsf{mem}~a)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{mem}~{\mathit{meminst}}{.}\mathsf{type})`. |
| |
| * The memory instance :math:`s{.}\mathsf{mems}{}[a]` exists. |
| |
| * The memory instance :math:`s{.}\mathsf{mems}{}[a]` is of the form :math:`{\mathit{meminst}}`. |
| * Or: |
| |
| * The external address :math:`{\mathit{externaddr}}` is of the form :math:`(\mathsf{table}~a)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{table}~{\mathit{tableinst}}{.}\mathsf{type})`. |
| |
| * The table instance :math:`s{.}\mathsf{tables}{}[a]` exists. |
| |
| * The table instance :math:`s{.}\mathsf{tables}{}[a]` is of the form :math:`{\mathit{tableinst}}`. |
| * Or: |
| |
| * The external address :math:`{\mathit{externaddr}}` is of the form :math:`(\mathsf{func}~a)`. |
| |
| * The external type :math:`{\mathit{externtype}}` is of the form :math:`(\mathsf{func}~{\mathit{funcinst}}{.}\mathsf{type})`. |
| |
| * The function instance :math:`s{.}\mathsf{funcs}{}[a]` exists. |
| |
| * The function instance :math:`s{.}\mathsf{funcs}{}[a]` is of the form :math:`{\mathit{funcinst}}`. |
| * Or: |
| |
| * The external address :math:`{\mathit{externaddr}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}'}`. |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the external type :math:`{\mathit{externtype}}` is :ref:`valid <valid-val>`. |
| |
| * The external type :math:`{\mathit{xt}'}` :ref:`matches <match>` the external type :math:`{\mathit{externtype}}`. |
| |
| |
| |
| |
| The external address :math:`(\mathsf{tag}~a)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{tag}~{\mathit{taginst}}{.}\mathsf{type})` if: |
| |
| |
| * The tag instance :math:`s{.}\mathsf{tags}{}[a]` exists. |
| |
| * The tag instance :math:`s{.}\mathsf{tags}{}[a]` is of the form :math:`{\mathit{taginst}}`. |
| |
| |
| |
| |
| The external address :math:`(\mathsf{global}~a)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{global}~{\mathit{globalinst}}{.}\mathsf{type})` if: |
| |
| |
| * The global instance :math:`s{.}\mathsf{globals}{}[a]` exists. |
| |
| * The global instance :math:`s{.}\mathsf{globals}{}[a]` is of the form :math:`{\mathit{globalinst}}`. |
| |
| |
| |
| |
| The external address :math:`(\mathsf{mem}~a)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{mem}~{\mathit{meminst}}{.}\mathsf{type})` if: |
| |
| |
| * The memory instance :math:`s{.}\mathsf{mems}{}[a]` exists. |
| |
| * The memory instance :math:`s{.}\mathsf{mems}{}[a]` is of the form :math:`{\mathit{meminst}}`. |
| |
| |
| |
| |
| The external address :math:`(\mathsf{table}~a)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{table}~{\mathit{tableinst}}{.}\mathsf{type})` if: |
| |
| |
| * The table instance :math:`s{.}\mathsf{tables}{}[a]` exists. |
| |
| * The table instance :math:`s{.}\mathsf{tables}{}[a]` is of the form :math:`{\mathit{tableinst}}`. |
| |
| |
| |
| |
| The external address :math:`(\mathsf{func}~a)` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{func}~{\mathit{funcinst}}{.}\mathsf{type})` if: |
| |
| |
| * The function instance :math:`s{.}\mathsf{funcs}{}[a]` exists. |
| |
| * The function instance :math:`s{.}\mathsf{funcs}{}[a]` is of the form :math:`{\mathit{funcinst}}`. |
| |
| |
| |
| |
| The external address :math:`{\mathit{externaddr}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}` if: |
| |
| |
| * The external address :math:`{\mathit{externaddr}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}'}`. |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the external type :math:`{\mathit{xt}}` is :ref:`valid <valid-val>`. |
| |
| * The external type :math:`{\mathit{xt}'}` :ref:`matches <match>` the external type :math:`{\mathit{xt}}`. |
| |
| |
| |
| |
| The identifier context :math:`I` is :ref:`valid <valid-val>` if: |
| |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{types}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{tags}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{globals}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{mems}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{tables}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{funcs}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{datas}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{elems}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{locals}~{\mathrm{disjoint}}` is true. |
| |
| * :math:`{\bigoplus}\, I{.}\mathsf{labels}~{\mathrm{disjoint}}` is true. |
| |
| * For all :math:`{{\mathit{field}}^\ast}` in :math:`{{{\mathit{field}}^\ast}^\ast}`: |
| |
| * :math:`{\bigoplus}\, {{\mathit{field}}^\ast}~{\mathrm{disjoint}}` is true. |
| |
| * The name sequence sequence :math:`{{{\mathit{field}}^\ast}^\ast}` is of the form :math:`I{.}\mathsf{fields}`. |
| |
| |
| |
| |
| The context :math:`C` is :ref:`valid <valid-val>` if: |
| |
| |
| * The context :math:`C` is of the form :math:`\{ \mathsf{types}~{{\mathit{dt}}^{n}},\;\allowbreak \mathsf{tags}~{{\mathit{jt}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{gt}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{mt}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{tt}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{f}}^\ast},\;\allowbreak \mathsf{datas}~{{\mathit{ok}}^\ast},\;\allowbreak \mathsf{elems}~{{\mathit{et}}^\ast},\;\allowbreak \mathsf{locals}~{{{\mathit{lt}}}^\ast},\;\allowbreak \mathsf{labels}~{{\mathit{rt}}^\ast},\;\allowbreak \mathsf{return}~{{\mathit{rt}'}^?},\;\allowbreak \mathsf{refs}~{x^\ast},\;\allowbreak \mathsf{recs}~{{\mathit{st}}^{m}} \}`. |
| |
| * The context :math:`C_0` is of the form :math:`\{ \mathsf{types}~{{\mathit{dt}}^{n}},\;\allowbreak \mathsf{return}~\epsilon \}`. |
| |
| * For all :math:`{\mathit{dt}}` in :math:`{{\mathit{dt}}^\ast}`: |
| |
| * Under the context :math:`\{ \mathsf{types}~{{\mathit{dt}}^{n}}{}[0 : i],\;\allowbreak \mathsf{return}~\epsilon \}`, the defined type :math:`{\mathit{dt}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{st}}` in :math:`{{\mathit{st}}^\ast}`: |
| |
| * Under the context :math:`\{ \mathsf{types}~{{\mathit{dt}}^{n}},\;\allowbreak \mathsf{return}~\epsilon,\;\allowbreak \mathsf{recs}~{{\mathit{st}}^{m}} \}`, the sub type :math:`{\mathit{st}}` is :ref:`valid <valid-val>` for :math:`i`. |
| |
| * For all :math:`{\mathit{jt}}` in :math:`{{\mathit{jt}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the tag type :math:`{\mathit{jt}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{gt}}` in :math:`{{\mathit{gt}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the global type :math:`{\mathit{gt}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{mt}}` in :math:`{{\mathit{mt}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the memory type :math:`{\mathit{mt}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{tt}}` in :math:`{{\mathit{tt}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the table type :math:`{\mathit{tt}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{dt}}_{\mathsf{f}}` in :math:`{{\mathit{dt}}_{\mathsf{f}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the defined type :math:`{\mathit{dt}}_{\mathsf{f}}` is :ref:`valid <valid-val>`. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{dt}}_{\mathsf{f}}` is :math:`(\mathsf{func}~t_1~\rightarrow~t_2)`. |
| |
| * For all :math:`{\mathit{et}}` in :math:`{{\mathit{et}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the reference type :math:`{\mathit{et}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{{\mathit{lt}}}` in :math:`{{{\mathit{lt}}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the local type :math:`{{\mathit{lt}}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{rt}}` in :math:`{{\mathit{rt}}^\ast}`: |
| |
| * Under the context :math:`C_0`, the result type :math:`{\mathit{rt}}` is :ref:`valid <valid-val>`. |
| |
| * If :math:`{\mathit{rt}'}` is defined, then: |
| |
| * Under the context :math:`C_0`, the result type :math:`{\mathit{rt}'}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`x` in :math:`{x^\ast}`: |
| |
| * The length of :math:`{{\mathit{dt}}_{\mathsf{f}}^\ast}` is greater than :math:`x`. |
| |
| |
| |
| |
| The value :math:`{{\mathit{val}}^?}` is :ref:`valid <valid-val>` with the local type :math:`({\mathit{init}}~t)` if: |
| |
| |
| * Either: |
| |
| * The value :math:`{{\mathit{val}}^?}` is of the form :math:`{\mathit{val}'}`. |
| |
| * The initialization status :math:`{\mathit{init}}` is of the form :math:`\mathsf{set}`. |
| |
| * The value :math:`{\mathit{val}'}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| * Or: |
| |
| * The value :math:`{{\mathit{val}}^?}` is absent. |
| |
| * The initialization status :math:`{\mathit{init}}` is of the form :math:`\mathsf{unset}`. |
| |
| * The value type :math:`t` is of the form :math:`\mathsf{bot}`. |
| |
| |
| |
| |
| The value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the local type :math:`(\mathsf{set}~t)` if: |
| |
| |
| * The value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| |
| |
| |
| The value :math:`\epsilon` is :ref:`valid <valid-val>` with the local type :math:`(\mathsf{unset}~\mathsf{bot})`. |
| |
| |
| |
| |
| The data instance :math:`\{ \mathsf{bytes}~{b^\ast} \}` is :ref:`valid <valid-val>` with the data type :math:`\mathsf{ok}`. |
| |
| |
| |
| |
| The element instance :math:`\{ \mathsf{type}~{\mathit{rt}},\;\allowbreak \mathsf{refs}~{{\mathit{ref}}^\ast} \}` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{rt}}` if: |
| |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the reference type :math:`{\mathit{rt}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{ref}}` in :math:`{{\mathit{ref}}^\ast}`: |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The export instance :math:`\{ \mathsf{name}~{\mathit{nm}},\;\allowbreak \mathsf{addr}~{\mathit{xa}} \}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The external address :math:`{\mathit{xa}}` is :ref:`valid <valid-val>` with the external type :math:`{\mathit{xt}}`. |
| |
| |
| |
| |
| The module instance :math:`\{ \mathsf{types}~{{\mathit{deftype}}^\ast},\;\allowbreak \mathsf{tags}~{{\mathit{tagaddr}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{globaladdr}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{memaddr}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{tableaddr}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{funcaddr}}^\ast},\;\allowbreak \mathsf{datas}~{{\mathit{dataaddr}}^\ast},\;\allowbreak \mathsf{elems}~{{\mathit{elemaddr}}^\ast},\;\allowbreak \mathsf{exports}~{{\mathit{exportinst}}^\ast} \}` is :ref:`valid <valid-val>` with the context :math:`\{ \mathsf{types}~{{\mathit{deftype}}^\ast},\;\allowbreak \mathsf{tags}~{{\mathit{tagtype}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{globaltype}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{memtype}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{tabletype}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{deftype}}_{\mathsf{f}}^\ast},\;\allowbreak \mathsf{datas}~{{\mathit{datatype}}^\ast},\;\allowbreak \mathsf{elems}~{{\mathit{elemtype}}^\ast},\;\allowbreak \mathsf{return}~\epsilon,\;\allowbreak \mathsf{refs}~{i^{i<{|{{\mathit{funcaddr}}^\ast}|}}},\;\allowbreak \mathsf{recs}~{{\mathit{subtype}}^\ast} \}` if: |
| |
| |
| * For all :math:`{\mathit{deftype}}` in :math:`{{\mathit{deftype}}^\ast}`: |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the defined type :math:`{\mathit{deftype}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{tagaddr}}` in :math:`{{\mathit{tagaddr}}^\ast}`, and corresponding :math:`{\mathit{tagtype}}` in :math:`{{\mathit{tagtype}}^\ast}`: |
| |
| * The external address :math:`(\mathsf{tag}~{\mathit{tagaddr}})` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{tag}~{\mathit{tagtype}})`. |
| |
| * For all :math:`{\mathit{globaladdr}}` in :math:`{{\mathit{globaladdr}}^\ast}`, and corresponding :math:`{\mathit{globaltype}}` in :math:`{{\mathit{globaltype}}^\ast}`: |
| |
| * The external address :math:`(\mathsf{global}~{\mathit{globaladdr}})` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{global}~{\mathit{globaltype}})`. |
| |
| * For all :math:`{\mathit{deftype}}_{\mathsf{f}}` in :math:`{{\mathit{deftype}}_{\mathsf{f}}^\ast}`, and corresponding :math:`{\mathit{funcaddr}}` in :math:`{{\mathit{funcaddr}}^\ast}`: |
| |
| * The external address :math:`(\mathsf{func}~{\mathit{funcaddr}})` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{func}~{\mathit{deftype}}_{\mathsf{f}})`. |
| |
| * For all :math:`{\mathit{memaddr}}` in :math:`{{\mathit{memaddr}}^\ast}`, and corresponding :math:`{\mathit{memtype}}` in :math:`{{\mathit{memtype}}^\ast}`: |
| |
| * The external address :math:`(\mathsf{mem}~{\mathit{memaddr}})` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{mem}~{\mathit{memtype}})`. |
| |
| * For all :math:`{\mathit{tableaddr}}` in :math:`{{\mathit{tableaddr}}^\ast}`, and corresponding :math:`{\mathit{tabletype}}` in :math:`{{\mathit{tabletype}}^\ast}`: |
| |
| * The external address :math:`(\mathsf{table}~{\mathit{tableaddr}})` is :ref:`valid <valid-val>` with the external type :math:`(\mathsf{table}~{\mathit{tabletype}})`. |
| |
| * For all :math:`{\mathit{dataaddr}}` in :math:`{{\mathit{dataaddr}}^\ast}`: |
| |
| * The data instance :math:`s{.}\mathsf{datas}{}[{\mathit{dataaddr}}]` exists. |
| |
| * For all :math:`{\mathit{dataaddr}}` in :math:`{{\mathit{dataaddr}}^\ast}`, and corresponding :math:`{\mathit{datatype}}` in :math:`{{\mathit{datatype}}^\ast}`: |
| |
| * The data instance :math:`s{.}\mathsf{datas}{}[{\mathit{dataaddr}}]` is :ref:`valid <valid-val>` with the data type :math:`{\mathit{datatype}}`. |
| |
| * For all :math:`{\mathit{elemaddr}}` in :math:`{{\mathit{elemaddr}}^\ast}`: |
| |
| * The element instance :math:`s{.}\mathsf{elems}{}[{\mathit{elemaddr}}]` exists. |
| |
| * For all :math:`{\mathit{elemaddr}}` in :math:`{{\mathit{elemaddr}}^\ast}`, and corresponding :math:`{\mathit{elemtype}}` in :math:`{{\mathit{elemtype}}^\ast}`: |
| |
| * The element instance :math:`s{.}\mathsf{elems}{}[{\mathit{elemaddr}}]` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{elemtype}}`. |
| |
| * For all :math:`{\mathit{exportinst}}` in :math:`{{\mathit{exportinst}}^\ast}`: |
| |
| * The export instance :math:`{\mathit{exportinst}}` is :ref:`valid <valid-val>`. |
| |
| * :math:`{{\mathit{exportinst}}{.}\mathsf{name}^\ast}~{\mathrm{disjoint}}` is true. |
| |
| * The length of :math:`{(\mathsf{tag}~{\mathit{tagaddr}})^\ast}~{(\mathsf{global}~{\mathit{globaladdr}})^\ast}~{(\mathsf{mem}~{\mathit{memaddr}})^\ast}~{(\mathsf{table}~{\mathit{tableaddr}})^\ast}~{(\mathsf{func}~{\mathit{funcaddr}})^\ast}` is greater than :math:`0`. |
| |
| * For all :math:`{\mathit{exportinst}}` in :math:`{{\mathit{exportinst}}^\ast}`: |
| |
| * :math:`{\mathit{exportinst}}{.}\mathsf{addr}` is contained in :math:`{(\mathsf{tag}~{\mathit{tagaddr}})^\ast}~{(\mathsf{global}~{\mathit{globaladdr}})^\ast}~{(\mathsf{mem}~{\mathit{memaddr}})^\ast}~{(\mathsf{table}~{\mathit{tableaddr}})^\ast}~{(\mathsf{func}~{\mathit{funcaddr}})^\ast}`. |
| |
| |
| |
| |
| The frame :math:`\{ \mathsf{locals}~{({{\mathit{val}}^?})^\ast},\;\allowbreak \mathsf{module}~{\mathit{moduleinst}} \}` is :ref:`valid <valid-val>` with the context :math:`C` with the field :math:`\mathsf{locals}` appended by :math:`{{{\mathit{lt}}}^\ast}` if: |
| |
| |
| * The module instance :math:`{\mathit{moduleinst}}` is :ref:`valid <valid-val>` with the context :math:`C`. |
| |
| * For all :math:`{{\mathit{lt}}}` in :math:`{{{\mathit{lt}}}^\ast}`, and corresponding :math:`{\mathit{val?}}` in :math:`{{\mathit{val?}}^\ast}`: |
| |
| * The value :math:`{{\mathit{val}}^?}` is :ref:`valid <valid-val>` with the local type :math:`{{\mathit{lt}}}`. |
| |
| |
| |
| |
| :math:`{\mathit{instr}}` is valid with :math:`{{\mathit{valtype}}^\ast}~{\rightarrow}_{{{\mathit{localidx}}^\ast}}\,{{\mathit{valtype}'}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The instruction :math:`{\mathit{instr}}` is :ref:`valid <valid-val>` with the instruction type :math:`{{\mathit{valtype}}^\ast}~{\rightarrow}_{{{\mathit{localidx}}^\ast}}\,{{\mathit{valtype}'}^\ast}`. |
| |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`{\mathit{ref}}`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The local index sequence :math:`{{\mathit{localidx}}^\ast}` is empty. |
| |
| * The value type sequence :math:`{{\mathit{valtype}'}^\ast}` is of the form :math:`{\mathit{rt}}`. |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({{\mathsf{label}}_{n}}{\{}~{{\mathit{instr}'}^\ast}~\}~{{\mathit{instr}''}^\ast})`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The local index sequence :math:`{{\mathit{localidx}}^\ast}` is empty. |
| |
| * :math:`{{\mathit{instr}'}^\ast}` is valid with :math:`{{t'}^{n}}~{\rightarrow}_{{{x'}^\ast}}\,{{\mathit{valtype}'}^\ast}`. |
| |
| * :math:`{{\mathit{instr}''}^\ast}` is valid with :math:`\epsilon~{\rightarrow}_{{x^\ast}}\,{{\mathit{valtype}'}^\ast}`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({{\mathsf{frame}}_{n}}{\{}~f~\}~{{\mathit{instr}''}^\ast})`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The local index sequence :math:`{{\mathit{localidx}}^\ast}` is empty. |
| |
| * The frame :math:`f` is :ref:`valid <valid-val>` with the context :math:`{C'}`. |
| |
| * :math:`{{\mathit{instr}''}^\ast}` is valid with :math:`{{\mathit{valtype}'}^{n}}`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}}^\ast}~\}~{{\mathit{instr}''}^\ast})`. |
| |
| * The local index sequence :math:`{{\mathit{localidx}}^\ast}` is empty. |
| |
| * For all :math:`{\mathit{catch}}` in :math:`{{\mathit{catch}}^\ast}`: |
| |
| * The catch clause :math:`{\mathit{catch}}` is :ref:`valid <valid-val>`. |
| |
| * :math:`{{\mathit{instr}''}^\ast}` is valid with :math:`{{\mathit{valtype}}^\ast}~{\rightarrow}_{{x^\ast}}\,{{\mathit{valtype}'}^\ast}`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`\mathsf{trap}`. |
| |
| * The local index sequence :math:`{{\mathit{localidx}}^\ast}` is empty. |
| |
| * The instruction type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| :math:`{\mathit{instr}}` is valid with :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}` if: |
| |
| |
| * The instruction :math:`{\mathit{instr}}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| |
| |
| |
| :math:`{\mathit{ref}}` is valid with :math:`\epsilon~\rightarrow~{\mathit{rt}}` if: |
| |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| :math:`({{\mathsf{label}}_{n}}{\{}~{{\mathit{instr}'}^\ast}~\}~{{\mathit{instr}}^\ast})` is valid with :math:`\epsilon~\rightarrow~{t^\ast}` if: |
| |
| |
| * :math:`{{\mathit{instr}'}^\ast}` is valid with :math:`{{t'}^{n}}~{\rightarrow}_{{{x'}^\ast}}\,{t^\ast}`. |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`\epsilon~{\rightarrow}_{{x^\ast}}\,{t^\ast}`. |
| |
| |
| |
| |
| :math:`({{\mathsf{frame}}_{n}}{\{}~f~\}~{{\mathit{instr}}^\ast})` is valid with :math:`\epsilon~\rightarrow~{t^{n}}` if: |
| |
| |
| * The frame :math:`f` is :ref:`valid <valid-val>` with the context :math:`{C'}`. |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{t^{n}}`. |
| |
| |
| |
| |
| :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}}^\ast}~\}~{{\mathit{instr}}^\ast})` is valid with :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * For all :math:`{\mathit{catch}}` in :math:`{{\mathit{catch}}^\ast}`: |
| |
| * The catch clause :math:`{\mathit{catch}}` is :ref:`valid <valid-val>`. |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| |
| |
| |
| :math:`\mathsf{trap}` is valid with :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{\mathit{it}}` if: |
| |
| |
| * Either: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is empty. |
| |
| * The instruction type :math:`{\mathit{it}}` is of the form :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| * Or: |
| |
| * The instruction sequence :math:`{{\mathit{instr}}^\ast}` is of the form :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}`. |
| |
| * The instruction type :math:`{\mathit{it}}` is of the form :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}~{x_2^\ast}}\,{t_3^\ast}`. |
| |
| * :math:`{\mathit{instr}}_1` is valid with :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}}\,{t_2^\ast}`. |
| |
| * For all :math:`x_1` in :math:`{x_1^\ast}`: |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` is of the form :math:`({\mathit{init}}~t)`. |
| |
| * :math:`{{\mathit{instr}}_2^\ast}` is valid with :math:`{t_2^\ast}~{\rightarrow}_{{x_2^\ast}}\,{t_3^\ast}`. |
| * Or: |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{\mathit{it}''}`. |
| |
| * The instruction type :math:`{\mathit{it}''}` :ref:`matches <match>` the instruction type :math:`{\mathit{it}}`. |
| |
| * The instruction type :math:`{\mathit{it}}` is :ref:`valid <valid-val>`. |
| * Or: |
| |
| * The instruction type :math:`{\mathit{it}}` is of the form :math:`{t^\ast}~{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t^\ast}~{t_2^\ast}`. |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| * The result type :math:`{t^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| :math:`\epsilon` is valid with :math:`\epsilon~\rightarrow~\epsilon`. |
| |
| |
| |
| |
| :math:`{\mathit{instr}}_1~{{\mathit{instr}}_2^\ast}` is valid with :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}~{x_2^\ast}}\,{t_3^\ast}` if: |
| |
| |
| * :math:`{\mathit{instr}}_1` is valid with :math:`{t_1^\ast}~{\rightarrow}_{{x_1^\ast}}\,{t_2^\ast}`. |
| |
| * For all :math:`x_1` in :math:`{x_1^\ast}`: |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` exists. |
| |
| * The local :math:`C{.}\mathsf{locals}{}[x_1]` is of the form :math:`({\mathit{init}}~t)`. |
| |
| * :math:`{t^\ast}` is the concatenation of all such :math:`t`. |
| |
| * :math:`{{\mathit{instr}}_2^\ast}` is valid with :math:`{t_2^\ast}~{\rightarrow}_{{x_2^\ast}}\,{t_3^\ast}`. |
| |
| |
| |
| |
| :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{\mathit{it}}` if: |
| |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{\mathit{it}'}`. |
| |
| * The instruction type :math:`{\mathit{it}'}` :ref:`matches <match>` the instruction type :math:`{\mathit{it}}`. |
| |
| * The instruction type :math:`{\mathit{it}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{t^\ast}~{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t^\ast}~{t_2^\ast}` if: |
| |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast}`. |
| |
| * The result type :math:`{t^\ast}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{t^\ast}` if: |
| |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`\epsilon~\rightarrow~{t^\ast}`. |
| |
| |
| |
| |
| The tag instance :math:`\{ \mathsf{type}~{\mathit{jt}} \}` is :ref:`valid <valid-val>` with the tag type :math:`{\mathit{jt}}` if: |
| |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the tag type :math:`{\mathit{jt}}` is :ref:`valid <valid-val>`. |
| |
| |
| |
| |
| The global instance :math:`\{ \mathsf{type}~({\mathsf{mut}^?}~t),\;\allowbreak \mathsf{value}~{\mathit{val}} \}` is :ref:`valid <valid-val>` with the global type :math:`({\mathsf{mut}^?}~t)` if: |
| |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the global type :math:`({\mathsf{mut}^?}~t)` is :ref:`valid <valid-val>`. |
| |
| * The value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| |
| |
| |
| The memory instance :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ n .. m ]~\mathsf{page}),\;\allowbreak \mathsf{bytes}~{b^\ast} \}` is :ref:`valid <valid-val>` with the memory type :math:`({\mathit{at}}~{}[ n .. m ]~\mathsf{page})` if: |
| |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the memory type :math:`({\mathit{at}}~{}[ n .. m ]~\mathsf{page})` is :ref:`valid <valid-val>`. |
| |
| * The length of :math:`{b^\ast}` is equal to :math:`n \cdot 64 \, {\mathrm{Ki}}`. |
| |
| |
| |
| |
| The table instance :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ n .. m ]~{\mathit{rt}}),\;\allowbreak \mathsf{refs}~{{\mathit{ref}}^\ast} \}` is :ref:`valid <valid-val>` with the table type :math:`({\mathit{at}}~{}[ n .. m ]~{\mathit{rt}})` if: |
| |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the table type :math:`({\mathit{at}}~{}[ n .. m ]~{\mathit{rt}})` is :ref:`valid <valid-val>`. |
| |
| * The length of :math:`{{\mathit{ref}}^\ast}` is equal to :math:`n`. |
| |
| * For all :math:`{\mathit{ref}}` in :math:`{{\mathit{ref}}^\ast}`: |
| |
| * The reference value :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with the reference type :math:`{\mathit{rt}}`. |
| |
| |
| |
| |
| The function instance :math:`\{ \mathsf{type}~{\mathit{dt}},\;\allowbreak \mathsf{module}~{\mathit{moduleinst}},\;\allowbreak \mathsf{code}~{\mathit{func}} \}` is :ref:`valid <valid-val>` with the defined type :math:`{\mathit{dt}}` if: |
| |
| |
| * Under the context :math:`\{ \mathsf{return}~\epsilon \}`, the defined type :math:`{\mathit{dt}}` is :ref:`valid <valid-val>`. |
| |
| * The module instance :math:`{\mathit{moduleinst}}` is :ref:`valid <valid-val>` with the context :math:`C`. |
| |
| * The function :math:`{\mathit{func}}` is :ref:`valid <valid-val>` with the defined type :math:`{\mathit{dt}'}`. |
| |
| * The defined type :math:`{\mathit{dt}'}` :ref:`matches <match>` the defined type :math:`{\mathit{dt}}`. |
| |
| |
| |
| |
| The structure instance :math:`\{ \mathsf{type}~{\mathit{dt}},\;\allowbreak \mathsf{fields}~{{\mathit{fv}}^\ast} \}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{dt}}` is :math:`(\mathsf{struct}~{({\mathsf{mut}^?}~{\mathit{zt}})^\ast})`. |
| |
| * For all :math:`{\mathit{fv}}` in :math:`{{\mathit{fv}}^\ast}`, and corresponding :math:`{\mathit{zt}}` in :math:`{{\mathit{zt}}^\ast}`: |
| |
| * The field value :math:`{\mathit{fv}}` is :ref:`valid <valid-val>` with the storage type :math:`{\mathit{zt}}`. |
| |
| |
| |
| |
| The array instance :math:`\{ \mathsf{type}~{\mathit{dt}},\;\allowbreak \mathsf{fields}~{{\mathit{fv}}^\ast} \}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{dt}}` is :math:`(\mathsf{array}~({\mathsf{mut}^?}~{\mathit{zt}}))`. |
| |
| * For all :math:`{\mathit{fv}}` in :math:`{{\mathit{fv}}^\ast}`: |
| |
| * The field value :math:`{\mathit{fv}}` is :ref:`valid <valid-val>` with the storage type :math:`{\mathit{zt}}`. |
| |
| |
| |
| |
| The exception instance :math:`\{ \mathsf{tag}~{\mathit{ta}},\;\allowbreak \mathsf{fields}~{{\mathit{val}}^\ast} \}` is :ref:`valid <valid-val>` if: |
| |
| |
| * The tag instance :math:`s{.}\mathsf{tags}{}[{\mathit{ta}}]` exists. |
| |
| * The tag type :math:`{\mathit{dt}}` is of the form :math:`s{.}\mathsf{tags}{}[{\mathit{ta}}]{.}\mathsf{type}`. |
| |
| * The :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{dt}}` is :math:`(\mathsf{func}~{t^\ast}~\rightarrow)`. |
| |
| * For all :math:`t` in :math:`{t^\ast}`, and corresponding :math:`{\mathit{val}}` in :math:`{{\mathit{val}}^\ast}`: |
| |
| * The value :math:`{\mathit{val}}` is :ref:`valid <valid-val>` with the value type :math:`t`. |
| |
| |
| |
| |
| The store :math:`s` is :ref:`valid <valid-val>` if: |
| |
| |
| * For all : |
| |
| * The tag instance :math:`{\mathit{taginst}}` is :ref:`valid <valid-val>` with the tag type :math:`{\mathit{tagtype}}`. |
| |
| * :math:`{{\mathit{taginst}}^\ast}` is the concatenation of all such :math:`{\mathit{taginst}}`. |
| |
| * For all : |
| |
| * The global instance :math:`{\mathit{globalinst}}` is :ref:`valid <valid-val>` with the global type :math:`{\mathit{globaltype}}`. |
| |
| * :math:`{{\mathit{globalinst}}^\ast}` is the concatenation of all such :math:`{\mathit{globalinst}}`. |
| |
| * For all : |
| |
| * The memory instance :math:`{\mathit{meminst}}` is :ref:`valid <valid-val>` with the memory type :math:`{\mathit{memtype}}`. |
| |
| * :math:`{{\mathit{meminst}}^\ast}` is the concatenation of all such :math:`{\mathit{meminst}}`. |
| |
| * For all : |
| |
| * The table instance :math:`{\mathit{tableinst}}` is :ref:`valid <valid-val>` with the table type :math:`{\mathit{tabletype}}`. |
| |
| * :math:`{{\mathit{tableinst}}^\ast}` is the concatenation of all such :math:`{\mathit{tableinst}}`. |
| |
| * For all : |
| |
| * The function instance :math:`{\mathit{funcinst}}` is :ref:`valid <valid-val>` with the defined type :math:`{\mathit{deftype}}`. |
| |
| * :math:`{{\mathit{funcinst}}^\ast}` is the concatenation of all such :math:`{\mathit{funcinst}}`. |
| |
| * For all : |
| |
| * The data instance :math:`{\mathit{datainst}}` is :ref:`valid <valid-val>` with the data type :math:`{\mathit{datatype}}`. |
| |
| * :math:`{{\mathit{datainst}}^\ast}` is the concatenation of all such :math:`{\mathit{datainst}}`. |
| |
| * For all : |
| |
| * The element instance :math:`{\mathit{eleminst}}` is :ref:`valid <valid-val>` with the element type :math:`{\mathit{elemtype}}`. |
| |
| * :math:`{{\mathit{eleminst}}^\ast}` is the concatenation of all such :math:`{\mathit{eleminst}}`. |
| |
| * For all :math:`{\mathit{structinst}}` in :math:`{{\mathit{structinst}}^\ast}`: |
| |
| * The structure instance :math:`{\mathit{structinst}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{arrayinst}}` in :math:`{{\mathit{arrayinst}}^\ast}`: |
| |
| * The array instance :math:`{\mathit{arrayinst}}` is :ref:`valid <valid-val>`. |
| |
| * For all :math:`{\mathit{exninst}}` in :math:`{{\mathit{exninst}}^\ast}`: |
| |
| * The exception instance :math:`{\mathit{exninst}}` is :ref:`valid <valid-val>`. |
| |
| * For all : |
| |
| * :math:`(\mathsf{ref{.}struct}~a)` is not immutably reachable from :math:`(\mathsf{ref{.}struct}~a)`. |
| |
| * :math:`(\mathsf{ref{.}array}~a)` is not immutably reachable from :math:`(\mathsf{ref{.}array}~a)`. |
| |
| * :math:`(\mathsf{ref{.}exn}~a)` is not immutably reachable from :math:`(\mathsf{ref{.}exn}~a)`. |
| |
| * The store :math:`s` is of the form :math:`\{ \mathsf{tags}~{{\mathit{taginst}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{globalinst}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{meminst}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{tableinst}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{funcinst}}^\ast},\;\allowbreak \mathsf{datas}~{{\mathit{datainst}}^\ast},\;\allowbreak \mathsf{elems}~{{\mathit{eleminst}}^\ast},\;\allowbreak \mathsf{structs}~{{\mathit{structinst}}^\ast},\;\allowbreak \mathsf{arrays}~{{\mathit{arrayinst}}^\ast},\;\allowbreak \mathsf{exns}~{{\mathit{exninst}}^\ast} \}`. |
| |
| |
| |
| |
| The state :math:`(s, f)` is :ref:`valid <valid-val>` with the context :math:`C` if: |
| |
| |
| * The store :math:`s` is :ref:`valid <valid-val>`. |
| |
| * The frame :math:`f` is :ref:`valid <valid-val>` with the context :math:`C`. |
| |
| |
| |
| |
| The configuration :math:`(s, f)~;~{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the result type :math:`{t^\ast}` if: |
| |
| |
| * The state :math:`(s, f)` is :ref:`valid <valid-val>` with the context :math:`C`. |
| |
| * :math:`{{\mathit{instr}}^\ast}` is valid with :math:`{t^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`{\mathit{instr}}` is :ref:`valid <valid-val>` with the instruction type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}` if: |
| |
| |
| * Either: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{i{\scriptstyle 32}} {.} \mathsf{add})`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is of the form :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}'}^\ast}` is of the form :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{global{.}get}~x)`. |
| |
| * The value type sequence :math:`{{\mathit{valtype}}^\ast}` is empty. |
| |
| * The value type sequence :math:`{{\mathit{valtype}'}^\ast}` is of the form :math:`t`. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\mathsf{mut}~t)`. |
| * Or: |
| |
| * The instruction :math:`{\mathit{instr}}` is of the form :math:`(\mathsf{block}~{\mathit{blocktype}}~{{\mathit{instr}'}^\ast})`. |
| |
| * The block type :math:`{\mathit{blocktype}}` is :ref:`valid <valid-val>` as the instruction type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{{\mathit{valtype}'}^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}'}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{{\mathit{valtype}}^\ast}~\rightarrow~{{\mathit{valtype}'}^\ast}`. |
| |
| |
| |
| |
| The instruction sequence :math:`(\mathsf{i{\scriptstyle 32}} {.} \mathsf{add})` is :ref:`valid <valid-val>` with the instruction type :math:`\mathsf{i{\scriptstyle 32}}~\mathsf{i{\scriptstyle 32}}~\rightarrow~\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| |
| |
| The instruction sequence :math:`(\mathsf{global{.}get}~x)` is :ref:`valid <valid-val>` with the instruction type :math:`\epsilon~\rightarrow~t` if: |
| |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` exists. |
| |
| * The global :math:`C{.}\mathsf{globals}{}[x]` is of the form :math:`(\mathsf{mut}~t)`. |
| |
| |
| |
| |
| The instruction sequence :math:`(\mathsf{block}~{\mathit{blocktype}}~{{\mathit{instr}}^\ast})` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}` if: |
| |
| |
| * The block type :math:`{\mathit{blocktype}}` is :ref:`valid <valid-val>` as the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| * Let :math:`{C'}` be the same context as :math:`C`, but with the result type sequence :math:`{t_2^\ast}` prepended to the field :math:`\mathsf{labels}`. |
| |
| * Under the context :math:`{C'}`, the instruction sequence :math:`{{\mathit{instr}}^\ast}` is :ref:`valid <valid-val>` with the instruction type :math:`{t_1^\ast}~\rightarrow~{t_2^\ast}`. |
| |
| |
| :math:`\mathsf{br}~l` |
| ..................... |
| |
| |
| 1. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Let :math:`L` be the topmost :math:`\mathsf{label}`. |
| |
| #. Let :math:`n` be the arity of :math:`L` |
| |
| #. If :math:`l = 0`, then: |
| |
| a. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Jump to the continuation of :math:`L`. |
| |
| #. Else: |
| |
| a. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{br}~l - 1)`. |
| |
| |
| :math:`\mathsf{return\_call\_ref}~y` |
| .................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}''}` from the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{frame}`. |
| |
| #. If :math:`{\mathit{val}''} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}''}` is some :math:`\mathsf{ref{.}func}~{\mathit{funcaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}func}~a)` be the destructuring of :math:`{\mathit{val}''}`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{funcs}|}`. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{funcs}{}[a]{.}\mathsf{type}` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{t_1^{n}}~\rightarrow~{t_2^{m}})` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{funcs}{}[a]{.}\mathsf{type}`. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{call\_ref}~y)`. |
| |
| |
| :math:`\mathsf{throw\_ref}` |
| ........................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{ref{.}exn}~a)` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{val}}^\ast} \neq \epsilon`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| |
| :math:`\mathsf{throw\_ref}` |
| ........................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{ref{.}exn}~a)` from the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{handler}`. |
| |
| #. Let :math:`H` be the topmost :math:`\mathsf{handler}`. |
| |
| #. Let :math:`n` be the arity of :math:`H` |
| |
| #. Let :math:`{{\mathit{catch}''}^\ast}` be the catch handler of :math:`H` |
| |
| #. If :math:`{{\mathit{catch}''}^\ast} = \epsilon`, then: |
| |
| a. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else if :math:`a \geq {|z{.}\mathsf{exns}|}`, then: |
| |
| a. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #. If :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch\_all}~{\mathit{labelidx}}`, then: |
| |
| 1) Let :math:`(\mathsf{catch\_all}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else if :math:`{\mathit{catch}}_0` is not some :math:`\mathsf{catch\_all\_ref}~{\mathit{labelidx}}`, then: |
| |
| 1) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Let :math:`{H'}` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #) Push the :math:`\mathsf{handler}` :math:`{H'}`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else: |
| |
| 1) Let :math:`(\mathsf{catch\_all\_ref}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. Let :math:`{{\mathit{val}}^\ast}` be :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{fields}`. |
| |
| #. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #. If :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch}~{\mathit{tagidx}}~{\mathit{labelidx}}`, then: |
| |
| 1) Let :math:`(\mathsf{catch}~x~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) If :math:`x < {|z{.}\mathsf{module}{.}\mathsf{tags}|}` and :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{tag} = z{.}\mathsf{module}{.}\mathsf{tags}{}[x]`, then: |
| |
| a) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #) Else: |
| |
| a) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Let :math:`{H'}` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #) Push the :math:`\mathsf{handler}` :math:`{H'}`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else if :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch\_ref}~{\mathit{tagidx}}~{\mathit{labelidx}}`, then: |
| |
| 1) Let :math:`(\mathsf{catch\_ref}~x~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) If :math:`x \geq {|z{.}\mathsf{module}{.}\mathsf{tags}|}` or :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{tag} \neq z{.}\mathsf{module}{.}\mathsf{tags}{}[x]`, then: |
| |
| a) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Let :math:`{H'}` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #) Push the :math:`\mathsf{handler}` :math:`{H'}`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #) Else: |
| |
| a) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| 1) If :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch\_all}~{\mathit{labelidx}}`, then: |
| |
| a) Let :math:`(\mathsf{catch\_all}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #) Else if :math:`{\mathit{catch}}_0` is not some :math:`\mathsf{catch\_all\_ref}~{\mathit{labelidx}}`, then: |
| |
| a) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Let :math:`H` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #) Push the :math:`\mathsf{handler}` :math:`H`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #) Else: |
| |
| a) Let :math:`(\mathsf{catch\_all\_ref}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| |
| :math:`\mathsf{table{.}copy}~x_1~x_2` |
| ..................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` from the stack. |
| |
| #. If :math:`i_1 + n > {|z{.}\mathsf{tables}{}[x_1]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`i_2 + n > {|z{.}\mathsf{tables}{}[x_2]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`\mathsf{table{.}init}~x~y` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`{\mathit{nt}}{.}\mathsf{load}~x~{\mathit{ao}}` |
| ..................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8]`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{N}{.}\mathsf{load}}{{n}{\mathsf{\_}}{{\mathit{sx}}}}~x~{\mathit{ao}}` |
| .......................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]`. |
| |
| #. Push the value :math:`({\mathsf{i}}{N}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{n, {|{\mathsf{i}}{N}|}}^{{\mathit{sx}}}}}{(c)})` to the stack. |
| |
| |
| :math:`{\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{K}{\mathsf{x}}{M}{\mathsf{\_}}{{\mathit{sx}}}}~x~{\mathit{ao}}` |
| ...................................................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + K \cdot M / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{j^{M}}` be the result for which :math:`{({{\mathrm{bytes}}}_{{\mathsf{i}}{K}}({j^{M}}) = z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} + k \cdot K / 8 : K / 8])^{k<M}}`. |
| |
| #. Let :math:`{\mathsf{i}}{N}` be the result for which :math:`N` :math:`=` :math:`K \cdot 2`. |
| |
| #. Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({{{{{\mathrm{extend}}}_{K, N}^{{\mathit{sx}}}}}{(j)}^{M}})}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{N}{\mathsf{\_}}{\mathsf{splat}}}~x~{\mathit{ao}}` |
| ........................................................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`M` be :math:`128 / N`. |
| |
| #. Let :math:`{\mathsf{i}}{N}` be the result for which :math:`{|{\mathsf{i}}{N}|}` :math:`=` :math:`N`. |
| |
| #. Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #. Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({j^{M}})}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{N}{\mathsf{\_}}{\mathsf{zero}}}~x~{\mathit{ao}}` |
| ....................................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #. Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{N, 128}^{\mathsf{u}}}}{(j)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{memory{.}copy}~x_1~x_2` |
| ...................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` from the stack. |
| |
| #. If :math:`i_1 + n > {|z{.}\mathsf{mems}{}[x_1]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`i_2 + n > {|z{.}\mathsf{mems}{}[x_2]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`\mathsf{memory{.}init}~x~y` |
| .................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| |
| :math:`{\mathit{nt}}{.}\mathsf{store}~x~{\mathit{ao}}` |
| ...................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)`. |
| |
| #. Replace :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8]` with :math:`{b^\ast}`. |
| |
| |
| :math:`{{\mathsf{i}}{N}{.}\mathsf{store}}{n}~x~{\mathit{ao}}` |
| ............................................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`{\mathsf{i}}{N}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}({{\mathrm{wrap}}}_{{|{\mathsf{i}}{N}|}, n}(c))`. |
| |
| #. Replace :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]` with :math:`{b^\ast}`. |
| |
| |
| :math:`\mathsf{unreachable}` |
| ............................ |
| |
| |
| 1. Trap. |
| |
| |
| :math:`\mathsf{nop}` |
| .................... |
| |
| |
| 1. Do nothing. |
| |
| |
| :math:`\mathsf{drop}` |
| ..................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| |
| :math:`\mathsf{select}~{({t^\ast})^?}` |
| ...................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}_2` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}_1` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Push the value :math:`{\mathit{val}}_1` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`{\mathit{val}}_2` to the stack. |
| |
| |
| :math:`\mathsf{if}~{\mathit{bt}}~{{\mathit{instr}}_1^\ast}~\mathsf{else}~{{\mathit{instr}}_2^\ast}` |
| ................................................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}_1^\ast})`. |
| |
| #. Else: |
| |
| a. Execute the instruction :math:`(\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}_2^\ast})`. |
| |
| |
| :math:`\mathsf{label}` |
| ...................... |
| |
| |
| 1. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{label}`. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| |
| :math:`\mathsf{br}~l` |
| ..................... |
| |
| |
| 1. If the first non-value entry of the stack is a :math:`\mathsf{label}`, then: |
| |
| a. Let :math:`L` be the topmost :math:`\mathsf{label}`. |
| |
| #. Let :math:`n` be the arity of :math:`L` |
| |
| #. If :math:`l = 0`, then: |
| |
| 1) Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #) Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #) Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #) Pop the :math:`\mathsf{label}` from the stack. |
| |
| #) Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #) Jump to the continuation of :math:`L`. |
| |
| #. Else: |
| |
| 1) Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #) Pop the :math:`\mathsf{label}` from the stack. |
| |
| #) Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l - 1)`. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{handler}`. |
| |
| #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| |
| :math:`\mathsf{br\_if}~l` |
| ......................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. If :math:`c \neq 0`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. Do nothing. |
| |
| |
| :math:`\mathsf{br\_table}~{l^\ast}~{l'}` |
| ........................................ |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i < {|{l^\ast}|}`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~{l^\ast}{}[i])`. |
| |
| #. Else: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~{l'})`. |
| |
| |
| :math:`\mathsf{br\_on\_null}~l` |
| ............................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| |
| :math:`\mathsf{br\_on\_non\_null}~l` |
| .................................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| |
| :math:`\mathsf{call\_indirect}~x~y` |
| ................................... |
| |
| |
| 1. Execute the instruction :math:`(\mathsf{table{.}get}~x)`. |
| |
| #. Execute the instruction :math:`(\mathsf{ref{.}cast}~(\mathsf{ref}~\mathsf{null}~y))`. |
| |
| #. Execute the instruction :math:`(\mathsf{call\_ref}~y)`. |
| |
| |
| :math:`\mathsf{return\_call\_indirect}~x~y` |
| ........................................... |
| |
| |
| 1. Execute the instruction :math:`(\mathsf{table{.}get}~x)`. |
| |
| #. Execute the instruction :math:`(\mathsf{ref{.}cast}~(\mathsf{ref}~\mathsf{null}~y))`. |
| |
| #. Execute the instruction :math:`(\mathsf{return\_call\_ref}~y)`. |
| |
| |
| :math:`\mathsf{frame}` |
| ...................... |
| |
| |
| 1. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Let :math:`n` be the arity of :math:`f` |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{frame}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| |
| :math:`\mathsf{return}` |
| ....................... |
| |
| |
| 1. If the first non-value entry of the stack is a :math:`\mathsf{frame}`, then: |
| |
| a. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Let :math:`n` be the arity of :math:`f` |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Else if the first non-value entry of the stack is a :math:`\mathsf{label}`, then: |
| |
| a. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{return}`. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{handler}`. |
| |
| #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{return}`. |
| |
| |
| :math:`\mathsf{handler}` |
| ........................ |
| |
| |
| 1. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{handler}`. |
| |
| #. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| |
| :math:`\mathsf{local{.}tee}~x` |
| .............................. |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{local{.}set}~x)`. |
| |
| |
| :math:`\mathsf{ref{.}i{\scriptstyle 31}}` |
| ......................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}i{\scriptstyle 31}}~{{\mathrm{wrap}}}_{32, 31}(i))` to the stack. |
| |
| |
| :math:`\mathsf{ref{.}is\_null}` |
| ............................... |
| |
| |
| 1. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. If :math:`{\mathit{ref}} = \mathsf{ref{.}null}`, then: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)` to the stack. |
| |
| |
| :math:`\mathsf{ref{.}as\_non\_null}` |
| .................................... |
| |
| |
| 1. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. If :math:`{\mathit{ref}} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Push the value :math:`{\mathit{ref}}` to the stack. |
| |
| |
| :math:`\mathsf{ref{.}eq}` |
| ......................... |
| |
| |
| 1. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}_2` from the stack. |
| |
| #. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}_1` from the stack. |
| |
| #. If :math:`{\mathit{ref}}_1 = \mathsf{ref{.}null}` and :math:`{\mathit{ref}}_2 = \mathsf{ref{.}null}`, then: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack. |
| |
| #. Else if :math:`{\mathit{ref}}_1 = {\mathit{ref}}_2`, then: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)` to the stack. |
| |
| |
| :math:`{\mathsf{i{\scriptstyle 31}{.}get}}{\mathsf{\_}}{{\mathit{sx}}}` |
| ....................................................................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}i{\scriptstyle 31}}~{\mathit{u{\kern-0.1em\scriptstyle 31}}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}i{\scriptstyle 31}}~i)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{31, 32}^{{\mathit{sx}}}}}{(i)})` to the stack. |
| |
| |
| :math:`\mathsf{array{.}new}~x` |
| .............................. |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}new\_fixed}~x~n)`. |
| |
| |
| :math:`\mathsf{extern{.}convert\_any}` |
| ...................................... |
| |
| |
| 1. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. If :math:`{\mathit{ref}} = \mathsf{ref{.}null}`, then: |
| |
| a. Push the value :math:`\mathsf{ref{.}null}` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{ref{.}extern}~{\mathit{ref}})` to the stack. |
| |
| |
| :math:`\mathsf{any{.}convert\_extern}` |
| ...................................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Push the value :math:`\mathsf{ref{.}null}` to the stack. |
| |
| #. If :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}extern}~{\mathit{ref}}`, then: |
| |
| a. Let :math:`(\mathsf{ref{.}extern}~{\mathit{ref}})` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. Push the value :math:`{\mathit{ref}}` to the stack. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{unop}}` |
| ......................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{unop}}}{{}_{{\mathit{nt}}}(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{unop}}}{{}_{{\mathit{nt}}}(c_1)}`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{binop}}` |
| .......................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{binop}}}{{}_{{\mathit{nt}}}(c_1, c_2)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{binop}}}{{}_{{\mathit{nt}}}(c_1, c_2)}`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{testop}}` |
| ........................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{testop}}}{{}_{{\mathit{nt}}}(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}} {.} {\mathit{relop}}` |
| .......................................... |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{relop}}}{{}_{{\mathit{nt}}}(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{nt}}_2 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{nt}}_1}` |
| ............................................................................ |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`{\mathit{nt}}_1` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{cvtop}}}{{}_{{\mathit{nt}}_1, {\mathit{nt}}_2}(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{cvtop}}}{{}_{{\mathit{nt}}_1, {\mathit{nt}}_2}(c_1)}`. |
| |
| #. Push the value :math:`({\mathit{nt}}_2{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvunop}}` |
| .......................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{vvunop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1)}|} > 0`. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vvunop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvbinop}}` |
| ........................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{vvbinop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1, c_2)}|} > 0`. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vvbinop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} {\mathit{vvternop}}` |
| ............................................................ |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_3)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{vvternop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1, c_2, c_3)}|} > 0`. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vvternop}}}{{}_{\mathsf{v{\scriptstyle 128}}}(c_1, c_2, c_3)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}} {.} \mathsf{any\_true}` |
| ........................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{inez}}}_{{|\mathsf{v{\scriptstyle 128}}|}}(c_1)`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vunop}}` |
| .......................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{vunop}}}{{}_{{\mathit{sh}}}(c_1)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vunop}}}{{}_{{\mathit{sh}}}(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vbinop}}` |
| ........................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{vbinop}}}{{}_{{\mathit{sh}}}(c_1, c_2)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vbinop}}}{{}_{{\mathit{sh}}}(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vternop}}` |
| ............................................ |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_3)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{vternop}}}{{}_{{\mathit{sh}}}(c_1, c_2, c_3)}` is empty, then: |
| |
| a. Trap. |
| |
| #. Let :math:`c` be an element of :math:`{{\mathit{vternop}}}{{}_{{\mathit{sh}}}(c_1, c_2, c_3)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{N}}{\mathsf{x}}{M} {.} \mathsf{all\_true}` |
| ............................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`{i^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(c_1)`. |
| |
| #. Let :math:`c` be :math:`{\Pi}\, {{{\mathrm{inez}}}_{N}(i)^\ast}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vrelop}}` |
| ........................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vrelop}}}{{}_{{\mathit{sh}}}(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{vshiftop}}` |
| ............................................. |
| |
| |
| 1. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vshiftop}}}{{}_{{\mathit{sh}}}}{(c_1, i)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}}{.}\mathsf{bitmask}` |
| ........................................ |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{\mathsf{vbitmask}}{{}_{{\mathit{sh}}}(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}} {.} {\mathit{swizzlop}}` |
| ............................................. |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{swizzlop}}}{{}_{{\mathit{sh}}}(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}}{.}\mathsf{shuffle}~{i^\ast}` |
| ................................................. |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{\mathsf{vshuffle}}{{}_{{\mathit{sh}}}({i^\ast}, c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{N}}{\mathsf{x}}{M}{.}\mathsf{splat}` |
| ......................................................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}_0 = {\mathrm{unpack}}({\mathsf{i}}{N})`. |
| |
| #. Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({{{\mathrm{pack}}}_{{\mathsf{i}}{N}}(c_1)^{M}})}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{{\mathit{lanetype}}}{\mathsf{x}}{M}{.}\mathsf{extract\_lane}}{\mathsf{\_}}{{{\mathit{sx}'}^?}}~i` |
| .......................................................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. If :math:`{{\mathit{sx}'}^?}` is not defined, then: |
| |
| a. Assert: Due to validation, :math:`{\mathit{lanetype}}` is number type. |
| |
| #. Assert: Due to validation, :math:`i < {|{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(c_1)|}`. |
| |
| #. Let :math:`c_2` be :math:`{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(c_1){}[i]`. |
| |
| #. Push the value :math:`({\mathit{lanetype}}{.}\mathsf{const}~c_2)` to the stack. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Let :math:`{\mathit{sx}}` be :math:`{{\mathit{sx}'}^?}`. |
| |
| #. Assert: Due to validation, :math:`i < {|{{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(c_1)|}`. |
| |
| #. Let :math:`c_2` be :math:`{{{{\mathrm{extend}}}_{{|{\mathit{lanetype}}|}, 32}^{{\mathit{sx}}}}}{({{\mathrm{lanes}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(c_1){}[i])}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~c_2)` to the stack. |
| |
| |
| :math:`{{\mathsf{i}}{N}}{\mathsf{x}}{M}{.}\mathsf{replace\_lane}~i` |
| ................................................................... |
| |
| |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}_0 = {\mathrm{unpack}}({\mathsf{i}}{N})`. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(c_1){}[{}[i] = {{\mathrm{pack}}}_{{\mathsf{i}}{N}}(c_2)])}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}}_2 {.} {{\mathit{vextunop}}}{\mathsf{\_}}{{\mathit{sh}}_1}` |
| ............................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vextunop}}}{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}(c_1)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}}_2 {.} {{\mathit{vextbinop}}}{\mathsf{\_}}{{\mathit{sh}}_1}` |
| ................................................................................ |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vextbinop}}}{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}}_2 {.} {{\mathit{vextternop}}}{\mathsf{\_}}{{\mathit{sh}}_1}` |
| ................................................................................. |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_3)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathit{vextternop}}}{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}(c_1, c_2, c_3)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{{\mathit{sh}}_2{.}\mathsf{narrow}}{\mathsf{\_}}{{\mathit{sh}}_1}{\mathsf{\_}}{{\mathit{sx}}}` |
| ..................................................................................................... |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_2)` from the stack. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{\mathsf{vnarrow}}{{{}_{{\mathit{sh}}_1, {\mathit{sh}}_2}^{{\mathit{sx}}}}}{(c_1, c_2)}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathit{sh}}_2 {.} {{\mathit{vcvtop}}}{\mathsf{\_}}{{\mathit{sh}}_1}` |
| ............................................................................. |
| |
| |
| 1. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Let :math:`c` be :math:`{{\mathrm{vcvtop}}}_{{\mathit{sh}}_1, {\mathit{sh}}_2}({\mathit{vcvtop}}, c_1)`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{block}~{\mathit{bt}}~{{\mathit{instr}}^\ast}` |
| ............................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`{t_1^{m}}~{\rightarrow}_{{{\mathit{localidx}}_0^\ast}}\,{t_2^{n}}` be the destructuring of :math:`{{\mathrm{blocktype}}}_{z}({\mathit{bt}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{localidx}}_0^\ast} = \epsilon`. |
| |
| #. Assert: Due to validation, there are at least :math:`m` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{m}}` from the stack. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`n` and whose continuation is the end of the block. |
| |
| #. Enter the block :math:`{{\mathit{val}}^{m}}~{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{loop}~{\mathit{bt}}~{{\mathit{instr}}^\ast}` |
| ........................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`{t_1^{m}}~{\rightarrow}_{{{\mathit{localidx}}_0^\ast}}\,{t_2^{n}}` be the destructuring of :math:`{{\mathrm{blocktype}}}_{z}({\mathit{bt}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{localidx}}_0^\ast} = \epsilon`. |
| |
| #. Assert: Due to validation, there are at least :math:`m` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{m}}` from the stack. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`m` and whose continuation is the start of the block. |
| |
| #. Enter the block :math:`{{\mathit{val}}^{m}}~{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{br\_on\_cast}~l~{\mathit{rt}}_1~{\mathit{rt}}_2` |
| ............................................................... |
| |
| |
| 1. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. Push the value :math:`{\mathit{ref}}` to the stack. |
| |
| #. If :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with type :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}}_2)`, then: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. Do nothing. |
| |
| |
| :math:`\mathsf{br\_on\_cast\_fail}~l~{\mathit{rt}}_1~{\mathit{rt}}_2` |
| ..................................................................... |
| |
| |
| 1. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. Push the value :math:`{\mathit{ref}}` to the stack. |
| |
| #. If :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with type :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}}_2)`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| |
| :math:`\mathsf{call}~x` |
| ....................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`x < {|z{.}\mathsf{module}{.}\mathsf{funcs}|}`. |
| |
| #. Let :math:`a` be the address :math:`z{.}\mathsf{module}{.}\mathsf{funcs}{}[x]`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{funcs}|}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{call\_ref}~z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`. |
| |
| |
| :math:`\mathsf{call\_ref}~y` |
| ............................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}'}` from the stack. |
| |
| #. If :math:`{\mathit{val}'} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}'}` is some :math:`\mathsf{ref{.}func}~{\mathit{funcaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}func}~a)` be the destructuring of :math:`{\mathit{val}'}`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{funcs}|}`. |
| |
| #. Let :math:`{\mathit{fi}}` be the function instance :math:`z{.}\mathsf{funcs}{}[a]`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{fi}}{.}\mathsf{code}` is some :math:`\mathsf{func}~{\mathit{typeidx}}~{{\mathit{local}}^\ast}~{\mathit{expr}}`. |
| |
| #. Let :math:`(\mathsf{func}~x~{{\mathit{local}}_0^\ast}~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{fi}}{.}\mathsf{code}`. |
| |
| #. Let :math:`{t^\ast}` be the value type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{local}}_0` in :math:`{{\mathit{local}}_0^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{local}~t)` be the destructuring of :math:`{\mathit{local}}_0`. |
| |
| #. Append :math:`t` to :math:`{t^\ast}`. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{fi}}{.}\mathsf{type}` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{t_1^{n}}~\rightarrow~{t_2^{m}})` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`{\mathit{fi}}{.}\mathsf{type}`. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Let :math:`f` be the frame :math:`\{ \mathsf{locals}~{{\mathit{val}}^{n}}~{{{\mathrm{default}}}_{t}^\ast},\;\allowbreak \mathsf{module}~{\mathit{fi}}{.}\mathsf{module} \}`. |
| |
| #. Let :math:`{f'}` be the :math:`\mathsf{frame}` :math:`f` whose arity is :math:`m`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{f'}`. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`m` and whose continuation is the end of the block. |
| |
| #. Enter the block :math:`{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{return\_call}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`x < {|z{.}\mathsf{module}{.}\mathsf{funcs}|}`. |
| |
| #. Let :math:`a` be the address :math:`z{.}\mathsf{module}{.}\mathsf{funcs}{}[x]`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{funcs}|}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{return\_call\_ref}~z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`. |
| |
| |
| :math:`\mathsf{return\_call\_ref}~y` |
| .................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. If the first non-value entry of the stack is a :math:`\mathsf{label}`, then: |
| |
| a. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{label}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{return\_call\_ref}~y)`. |
| |
| #. Else if the first non-value entry of the stack is a :math:`\mathsf{handler}`, then: |
| |
| a. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{return\_call\_ref}~y)`. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, the first non-value entry of the stack is a :math:`\mathsf{frame}`. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}''}` from the stack. |
| |
| #. If :math:`{\mathit{val}''} = \mathsf{ref{.}null}`, then: |
| |
| 1) Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}''}` is some :math:`\mathsf{ref{.}func}~{\mathit{funcaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}func}~a)` be the destructuring of :math:`{\mathit{val}''}`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{funcs}|}`. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{funcs}{}[a]{.}\mathsf{type}` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{t_1^{n}}~\rightarrow~{t_2^{m}})` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{funcs}{}[a]{.}\mathsf{type}`. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{call\_ref}~y)`. |
| |
| |
| :math:`\mathsf{throw\_ref}` |
| ........................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}'}` from the stack. |
| |
| #. If :math:`{\mathit{val}'} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`{\mathit{val}'}` is some :math:`\mathsf{ref{.}exn}~{\mathit{exnaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{ref{.}exn}~a)` be the destructuring of :math:`{\mathit{val}'}`. |
| |
| #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack. |
| |
| #. If :math:`{{\mathit{val}}^\ast} \neq \epsilon`, then: |
| |
| 1) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else if the first non-value entry of the stack is a :math:`\mathsf{label}`, then: |
| |
| 1) Pop the :math:`\mathsf{label}` from the stack. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else: |
| |
| 1) If the first non-value entry of the stack is a :math:`\mathsf{frame}`, then: |
| |
| a) Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #) Else if the first non-value entry of the stack is not a :math:`\mathsf{handler}`, then: |
| |
| a) Throw the exception :math:`{\mathit{val}'}` as a result. |
| |
| #) Else: |
| |
| a) Let :math:`H` be the topmost :math:`\mathsf{handler}`. |
| |
| #) Let :math:`n` be the arity of :math:`H` |
| |
| #) Let :math:`{{\mathit{catch}''}^\ast}` be the catch handler of :math:`H` |
| |
| #) If :math:`{{\mathit{catch}''}^\ast} = \epsilon`, then: |
| |
| 1. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #) Else if :math:`a \geq {|z{.}\mathsf{exns}|}`, then: |
| |
| 1. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #. If :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch\_all}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{catch\_all}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else if :math:`{\mathit{catch}}_0` is not some :math:`\mathsf{catch\_all\_ref}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Let :math:`{H'}` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #. Push the :math:`\mathsf{handler}` :math:`{H'}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else: |
| |
| a. Let :math:`(\mathsf{catch\_all\_ref}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #. Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #) Else: |
| |
| 1. Let :math:`{{\mathit{val}}^\ast}` be :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{fields}`. |
| |
| #. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #. If :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch}~{\mathit{tagidx}}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{catch}~x~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #. If :math:`x < {|z{.}\mathsf{module}{.}\mathsf{tags}|}` and :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{tag} = z{.}\mathsf{module}{.}\mathsf{tags}{}[x]`, then: |
| |
| 1) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| 1) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Let :math:`{H'}` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #) Push the :math:`\mathsf{handler}` :math:`{H'}`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else if :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch\_ref}~{\mathit{tagidx}}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{catch\_ref}~x~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #. If :math:`x \geq {|z{.}\mathsf{module}{.}\mathsf{tags}|}` or :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{tag} \neq z{.}\mathsf{module}{.}\mathsf{tags}{}[x]`, then: |
| |
| 1) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Let :math:`{H'}` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #) Push the :math:`\mathsf{handler}` :math:`{H'}`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else: |
| |
| 1) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. If :math:`{\mathit{catch}}_0` is some :math:`\mathsf{catch\_all}~{\mathit{labelidx}}`, then: |
| |
| 1) Let :math:`(\mathsf{catch\_all}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else if :math:`{\mathit{catch}}_0` is not some :math:`\mathsf{catch\_all\_ref}~{\mathit{labelidx}}`, then: |
| |
| 1) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}''}^\ast}`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Let :math:`H` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}'}^\ast}`. |
| |
| #) Push the :math:`\mathsf{handler}` :math:`H`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| #. Else: |
| |
| 1) Let :math:`(\mathsf{catch\_all\_ref}~l)` be the destructuring of :math:`{\mathit{catch}}_0`. |
| |
| #) Pop the :math:`\mathsf{handler}` from the stack. |
| |
| #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{br}~l)`. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, the first non-value entry of the stack is not a :math:`\mathsf{label}`. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is not a :math:`\mathsf{frame}`. |
| |
| #. Assert: Due to validation, the first non-value entry of the stack is not a :math:`\mathsf{handler}`. |
| |
| #. Throw the exception :math:`{\mathit{val}'}` as a result. |
| |
| |
| :math:`\mathsf{try\_table}~{\mathit{bt}}~{{\mathit{catch}}^\ast}~{{\mathit{instr}}^\ast}` |
| ......................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`{t_1^{m}}~{\rightarrow}_{{{\mathit{localidx}}_0^\ast}}\,{t_2^{n}}` be the destructuring of :math:`{{\mathrm{blocktype}}}_{z}({\mathit{bt}})`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{localidx}}_0^\ast} = \epsilon`. |
| |
| #. Assert: Due to validation, there are at least :math:`m` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{m}}` from the stack. |
| |
| #. Let :math:`H` be the :math:`\mathsf{handler}` whose arity is :math:`n` and whose catch handler is :math:`{{\mathit{catch}}^\ast}`. |
| |
| #. Push the :math:`\mathsf{handler}` :math:`H`. |
| |
| #. Let :math:`L` be the :math:`\mathsf{label}` whose arity is :math:`n` and whose continuation is the end of the block. |
| |
| #. Enter the block :math:`{{\mathit{val}}^{m}}~{{\mathit{instr}}^\ast}` with the :math:`\mathsf{label}` :math:`L`. |
| |
| |
| :math:`\mathsf{local{.}get}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`z{.}\mathsf{locals}{}[x]` is defined. |
| |
| #. Let :math:`{\mathit{val}}` be :math:`z{.}\mathsf{locals}{}[x]`. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| |
| :math:`\mathsf{global{.}get}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`{\mathit{val}}` be the value :math:`z{.}\mathsf{globals}{}[x]{.}\mathsf{value}`. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| |
| :math:`\mathsf{table{.}get}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i \geq {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. Push the value :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i]` to the stack. |
| |
| |
| :math:`\mathsf{table{.}size}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`({\mathit{at}}~{\mathit{lim}}~{\mathit{rt}})` be the destructuring of :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{type}`. |
| |
| #. Let :math:`n` be the length of :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` to the stack. |
| |
| |
| :math:`\mathsf{table{.}fill}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`{\mathit{at}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}set}~x)`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}fill}~x)`. |
| |
| |
| :math:`\mathsf{table{.}copy}~x_1~x_2` |
| ..................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` from the stack. |
| |
| #. If :math:`i_1 + n > {|z{.}\mathsf{tables}{}[x_1]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`i_2 + n > {|z{.}\mathsf{tables}{}[x_2]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. If :math:`i_1 \leq i_2`, then: |
| |
| 1) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}get}~x_2)`. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}set}~x_1)`. |
| |
| #) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1 + 1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2 + 1)` to the stack. |
| |
| #. Else: |
| |
| 1) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1 + n - 1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2 + n - 1)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}get}~x_2)`. |
| |
| #) Execute the instruction :math:`(\mathsf{table{.}set}~x_1)`. |
| |
| #) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` to the stack. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}copy}~x_1~x_2)`. |
| |
| |
| :math:`\mathsf{table{.}init}~x~y` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`j < {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}{}[j]` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}set}~x)`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{table{.}init}~x~y)`. |
| |
| |
| :math:`{{\mathit{nt}}{.}\mathsf{load}}{{{\mathit{loadop}}^?}}~x~{\mathit{ao}}` |
| .............................................................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`{{\mathit{loadop}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8]`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`{\mathit{nt}}` is :math:`{\mathsf{i}}{N}`. |
| |
| #. Let :math:`{\mathit{loadop}}_0` be :math:`{{\mathit{loadop}}^?}`. |
| |
| #. Let :math:`{n}{\mathsf{\_}}{{\mathit{sx}}}` be the destructuring of :math:`{\mathit{loadop}}_0`. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]`. |
| |
| #. Push the value :math:`({\mathit{nt}}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{n, {|{\mathit{nt}}|}}^{{\mathit{sx}}}}}{(c)})` to the stack. |
| |
| |
| :math:`{\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{{{\mathit{vloadop}}^?}}~x~{\mathit{ao}}` |
| .............................................................................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`{{\mathit{vloadop}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|\mathsf{v{\scriptstyle 128}}|} / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{\mathsf{v{\scriptstyle 128}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|\mathsf{v{\scriptstyle 128}}|} / 8]`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{vloadop}}_0` be :math:`{{\mathit{vloadop}}^?}`. |
| |
| #. If :math:`{\mathit{vloadop}}_0` is some :math:`{{\mathit{sz}}}{\mathsf{x}}{M}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({K}{\mathsf{x}}{M}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vloadop}}_0`. |
| |
| #) If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + K \cdot M / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a) Trap. |
| |
| #) Let :math:`{j^{M}}` be the result for which :math:`{({{\mathrm{bytes}}}_{{\mathsf{i}}{K}}({j^{M}}) = z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} + k \cdot K / 8 : K / 8])^{k<M}}`. |
| |
| #) Let :math:`{\mathsf{i}}{N}` be the result for which :math:`N` :math:`=` :math:`K \cdot 2`. |
| |
| #) Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({{{{{\mathrm{extend}}}_{K, N}^{{\mathit{sx}}}}}{(j)}^{M}})}`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. If :math:`{\mathit{vloadop}}_0` is some :math:`{{\mathit{sz}}}{\mathsf{\_}}{\mathsf{splat}}`, then: |
| |
| 1) Let :math:`({N}{\mathsf{\_}}{\mathsf{splat}})` be the destructuring of :math:`{\mathit{vloadop}}_0`. |
| |
| #) If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a) Trap. |
| |
| #) Let :math:`M` be :math:`128 / N`. |
| |
| #) Let :math:`{\mathsf{i}}{N}` be the result for which :math:`{|{\mathsf{i}}{N}|}` :math:`=` :math:`N`. |
| |
| #) Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #) Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({j^{M}})}`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| #. If :math:`{\mathit{vloadop}}_0` is some :math:`{{\mathit{sz}}}{\mathsf{\_}}{\mathsf{zero}}`, then: |
| |
| 1) Let :math:`({N}{\mathsf{\_}}{\mathsf{zero}})` be the destructuring of :math:`{\mathit{vloadop}}_0`. |
| |
| #) If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a) Trap. |
| |
| #) Let :math:`j` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(j)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #) Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{N, 128}^{\mathsf{u}}}}{(j)}`. |
| |
| #) Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`{\mathsf{v{\scriptstyle 128}}{.}\mathsf{load}}{N}{\mathsf{\_}}{\mathsf{lane}}~x~{\mathit{ao}}~j` |
| ....................................................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c_1)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`M` be :math:`{|\mathsf{v{\scriptstyle 128}}|} / N`. |
| |
| #. Let :math:`{\mathsf{i}}{N}` be the result for which :math:`{|{\mathsf{i}}{N}|}` :math:`=` :math:`N`. |
| |
| #. Let :math:`k` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}(k)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]`. |
| |
| #. Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(c_1){}[{}[j] = k])}`. |
| |
| #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack. |
| |
| |
| :math:`\mathsf{memory{.}size}~x` |
| ................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Let :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})` be the destructuring of :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{type}`. |
| |
| #. Let :math:`n \cdot 64 \, {\mathrm{Ki}}` be the length of :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` to the stack. |
| |
| |
| :math:`\mathsf{memory{.}fill}~x` |
| ................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`{\mathit{at}}` is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8}~x)`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{memory{.}fill}~x)`. |
| |
| |
| :math:`\mathsf{memory{.}copy}~x_1~x_2` |
| ...................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` from the stack. |
| |
| #. If :math:`i_1 + n > {|z{.}\mathsf{mems}{}[x_1]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`i_2 + n > {|z{.}\mathsf{mems}{}[x_2]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. If :math:`i_1 \leq i_2`, then: |
| |
| 1) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` to the stack. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{load}}{{8}{\mathsf{\_}}{\mathsf{u}}}~x_2)`. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8}~x_1)`. |
| |
| #) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1 + 1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2 + 1)` to the stack. |
| |
| #. Else: |
| |
| 1) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1 + n - 1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2 + n - 1)` to the stack. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{load}}{{8}{\mathsf{\_}}{\mathsf{u}}}~x_2)`. |
| |
| #) Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8}~x_1)`. |
| |
| #) Push the value :math:`({\mathit{at}}_1{.}\mathsf{const}~i_1)` to the stack. |
| |
| #) Push the value :math:`({\mathit{at}}_2{.}\mathsf{const}~i_2)` to the stack. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{memory{.}copy}~x_1~x_2)`. |
| |
| |
| :math:`\mathsf{memory{.}init}~x~y` |
| .................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`j < {|z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}|}`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}{}[j])` to the stack. |
| |
| #. Execute the instruction :math:`({\mathsf{i{\scriptstyle 32}}{.}\mathsf{store}}{8}~x)`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{memory{.}init}~x~y)`. |
| |
| |
| :math:`\mathsf{ref{.}null}~{\mathit{ht}}` |
| ......................................... |
| |
| |
| 1. Push the value :math:`\mathsf{ref{.}null}` to the stack. |
| |
| |
| :math:`\mathsf{ref{.}func}~x` |
| ............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`x < {|z{.}\mathsf{module}{.}\mathsf{funcs}|}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}func}~z{.}\mathsf{module}{.}\mathsf{funcs}{}[x])` to the stack. |
| |
| |
| :math:`\mathsf{ref{.}test}~{\mathit{rt}}` |
| ......................................... |
| |
| |
| 1. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. If :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with type :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}})`, then: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)` to the stack. |
| |
| |
| :math:`\mathsf{ref{.}cast}~{\mathit{rt}}` |
| ......................................... |
| |
| |
| 1. Let :math:`f` be the topmost :math:`\mathsf{frame}`. |
| |
| #. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. If not :math:`{\mathit{ref}}` is :ref:`valid <valid-val>` with type :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}})`, then: |
| |
| a. Trap. |
| |
| #. Push the value :math:`{\mathit{ref}}` to the stack. |
| |
| |
| :math:`\mathsf{struct{.}new\_default}~x` |
| ........................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{struct}~{\mathit{list}}({\mathit{fieldtype}})`. |
| |
| #. Let :math:`(\mathsf{struct}~{\mathit{list}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`{({\mathsf{mut}^?}~{\mathit{zt}})^\ast}` be :math:`{\mathit{list}}_0`. |
| |
| #. Assert: Due to validation, for all :math:`{\mathit{zt}}` in :math:`{{\mathit{zt}}^\ast}`, :math:`{{\mathrm{default}}}_{{\mathrm{unpack}}({\mathit{zt}})}` is defined. |
| |
| #. Let :math:`{{\mathit{val}}^\ast}` be the value sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{zt}}` in :math:`{{\mathit{zt}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{val}}` be :math:`{{\mathrm{default}}}_{{\mathrm{unpack}}({\mathit{zt}})}`. |
| |
| #. Append :math:`{\mathit{val}}` to :math:`{{\mathit{val}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{val}}^\ast}|} = {|{{\mathit{zt}}^\ast}|}`. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{struct{.}new}~x)`. |
| |
| |
| :math:`{\mathsf{struct{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x~i` |
| ................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}struct}~{\mathit{structaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}struct}~a)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. Assert: Due to validation, :math:`i < {|z{.}\mathsf{structs}{}[a]{.}\mathsf{fields}|}`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{structs}|}`. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{struct}~{\mathit{list}}({\mathit{fieldtype}})`. |
| |
| #. Let :math:`(\mathsf{struct}~{\mathit{list}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`{({\mathsf{mut}^?}~{\mathit{zt}})^\ast}` be :math:`{\mathit{list}}_0`. |
| |
| #. Assert: Due to validation, :math:`i < {|{{\mathit{zt}}^\ast}|}`. |
| |
| #. Push the value :math:`{{{{\mathrm{unpack}}}_{{{\mathit{zt}}^\ast}{}[i]}^{{{\mathit{sx}}^?}}}}{(z{.}\mathsf{structs}{}[a]{.}\mathsf{fields}{}[i])}` to the stack. |
| |
| |
| :math:`\mathsf{array{.}new\_default}~x` |
| ....................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`. |
| |
| #. Let :math:`(\mathsf{array}~{\mathit{fieldtype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`({\mathsf{mut}^?}~{\mathit{zt}})` be the destructuring of :math:`{\mathit{fieldtype}}_0`. |
| |
| #. Assert: Due to validation, :math:`{{\mathrm{default}}}_{{\mathrm{unpack}}({\mathit{zt}})}` is defined. |
| |
| #. Let :math:`{\mathit{val}}` be :math:`{{\mathrm{default}}}_{{\mathrm{unpack}}({\mathit{zt}})}`. |
| |
| #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}new\_fixed}~x~n)`. |
| |
| |
| :math:`\mathsf{array{.}new\_elem}~x~y` |
| ...................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + n > {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{{\mathit{ref}}^{n}}` be :math:`z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}{}[i : n]`. |
| |
| #. Push the values :math:`{{\mathit{ref}}^{n}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}new\_fixed}~x~n)`. |
| |
| |
| :math:`\mathsf{array{.}new\_data}~x~y` |
| ...................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`. |
| |
| #. Let :math:`(\mathsf{array}~{\mathit{fieldtype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`({\mathsf{mut}^?}~{\mathit{zt}})` be the destructuring of :math:`{\mathit{fieldtype}}_0`. |
| |
| #. If :math:`i + n \cdot {|{\mathit{zt}}|} / 8 > {|z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{{{\mathit{byte}}^\ast}^\ast}` be the result for which each :math:`{{\mathit{byte}}^\ast}` has length :math:`{|{\mathit{zt}}|} / 8`, and the :ref:`concatenation <notation-concat>` of :math:`{{{\mathit{byte}}^\ast}^\ast}` is :math:`z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}{}[i : n \cdot {|{\mathit{zt}}|} / 8]`. |
| |
| #. Let :math:`{c^{n}}` be the result for which :math:`{({{\mathrm{bytes}}}_{{\mathit{zt}}}({c^{n}}) = {{\mathit{byte}}^\ast})^\ast}`. |
| |
| #. Push the values :math:`{{\mathrm{unpack}}({\mathit{zt}}){.}\mathsf{const}~{{\mathrm{unpack}}}_{{\mathit{zt}}}(c)^{n}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}new\_fixed}~x~n)`. |
| |
| |
| :math:`{\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x` |
| ................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}array}~a)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{arrays}|}`. |
| |
| #. If :math:`i \geq {|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`. |
| |
| #. Let :math:`(\mathsf{array}~{\mathit{fieldtype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`({\mathsf{mut}^?}~{\mathit{zt}})` be the destructuring of :math:`{\mathit{fieldtype}}_0`. |
| |
| #. Push the value :math:`{{{{\mathrm{unpack}}}_{{\mathit{zt}}}^{{{\mathit{sx}}^?}}}}{(z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}{}[i])}` to the stack. |
| |
| |
| :math:`\mathsf{array{.}len}` |
| ............................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}array}~a)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. Assert: Due to validation, :math:`a < {|z{.}\mathsf{arrays}|}`. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|})` to the stack. |
| |
| |
| :math:`\mathsf{array{.}fill}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}'}` from the stack. |
| |
| #. If :math:`{\mathit{val}'} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}'}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}array}~a)` be the destructuring of :math:`{\mathit{val}'}`. |
| |
| #. If :math:`a \geq {|z{.}\mathsf{arrays}|}`, then: |
| |
| a. Do nothing. |
| |
| #. Else if :math:`i + n > {|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else: |
| |
| a. Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}set}~x)`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`{\mathit{val}}` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}fill}~x)`. |
| |
| |
| :math:`\mathsf{array{.}copy}~x_1~x_2` |
| ..................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}'}` from the stack. |
| |
| #. If :math:`{\mathit{val}'} = \mathsf{ref{.}null}` and :math:`{\mathit{val}}` is reference value, then: |
| |
| a. Trap. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}` and :math:`{\mathit{val}'}` is reference value, then: |
| |
| a. Trap. |
| |
| #. If :math:`{\mathit{val}'}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{ref{.}array}~a_1)` be the destructuring of :math:`{\mathit{val}'}`. |
| |
| #. If :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`, then: |
| |
| 1) If :math:`a_1 < {|z{.}\mathsf{arrays}|}` and :math:`i_1 + n > {|z{.}\mathsf{arrays}{}[a_1]{.}\mathsf{fields}|}`, then: |
| |
| a) Trap. |
| |
| #) Let :math:`(\mathsf{ref{.}array}~a_2)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #) If :math:`a_2 \geq {|z{.}\mathsf{arrays}|}`, then: |
| |
| a) Do nothing. |
| |
| #) Else if :math:`i_2 + n > {|z{.}\mathsf{arrays}{}[a_2]{.}\mathsf{fields}|}`, then: |
| |
| a) Trap. |
| |
| #) If :math:`n = 0`, then: |
| |
| a) Do nothing. |
| |
| #) Else: |
| |
| a) Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x_2]` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`. |
| |
| #) Let :math:`(\mathsf{array}~{\mathit{fieldtype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x_2]`. |
| |
| #) Let :math:`({\mathsf{mut}^?}~{\mathit{zt}}_2)` be the destructuring of :math:`{\mathit{fieldtype}}_0`. |
| |
| #) Let :math:`{{\mathit{sx}}^?}` be :math:`{\mathrm{sx}}({\mathit{zt}}_2)`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack. |
| |
| #) If :math:`i_1 \leq i_2`, then: |
| |
| 1. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2)` to the stack. |
| |
| #. Execute the instruction :math:`({\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x_2)`. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}set}~x_1)`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1 + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2 + 1)` to the stack. |
| |
| #) Else: |
| |
| 1. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1 + n - 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2 + n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`({\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x_2)`. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}set}~x_1)`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{array{.}copy}~x_1~x_2)`. |
| |
| |
| :math:`\mathsf{array{.}init\_elem}~x~y` |
| ....................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}array}~a)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. If :math:`a < {|z{.}\mathsf{arrays}|}` and :math:`i + n > {|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`j + n > {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| #. Else if :math:`j < {|z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}|}`, then: |
| |
| a. Let :math:`{\mathit{ref}}` be the reference value :math:`z{.}\mathsf{elems}{}[y]{.}\mathsf{refs}{}[j]`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #. Push the value :math:`{\mathit{ref}}` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}set}~x)`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + 1)` to the stack. |
| |
| #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{array{.}init\_elem}~x~y)`. |
| |
| |
| :math:`\mathsf{array{.}init\_data}~x~y` |
| ....................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j)` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. If :math:`{\mathit{val}} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}array}~a)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. If :math:`a < {|z{.}\mathsf{arrays}|}` and :math:`i + n > {|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|}`, then: |
| |
| a. Trap. |
| |
| #. If the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`, then: |
| |
| a. Let :math:`(\mathsf{array}~{\mathit{fieldtype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`({\mathsf{mut}^?}~{\mathit{zt}})` be the destructuring of :math:`{\mathit{fieldtype}}_0`. |
| |
| #. If :math:`j + n \cdot {|{\mathit{zt}}|} / 8 > {|z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. If :math:`n = 0`, then: |
| |
| 1) Do nothing. |
| |
| #. Else: |
| |
| 1) Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathit{zt}}}(c)` :math:`=` :math:`z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}{}[j : {|{\mathit{zt}}|} / 8]`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack. |
| |
| #) Push the value :math:`{\mathrm{unpack}}({\mathit{zt}}){.}\mathsf{const}~{{\mathrm{unpack}}}_{{\mathit{zt}}}(c)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{array{.}set}~x)`. |
| |
| #) Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + {|{\mathit{zt}}|} / 8)` to the stack. |
| |
| #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack. |
| |
| #) Execute the instruction :math:`(\mathsf{array{.}init\_data}~x~y)`. |
| |
| #. Else if :math:`n = 0`, then: |
| |
| a. Do nothing. |
| |
| |
| :math:`\mathsf{throw}~x` |
| ........................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, :math:`x < {|z{.}\mathsf{module}{.}\mathsf{tags}|}`. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{tags}{}[x]{.}\mathsf{type}` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{t^{n}}~\rightarrow~{\mathit{resulttype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{tags}{}[x]{.}\mathsf{type}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{resulttype}}_0 = \epsilon`. |
| |
| #. Let :math:`a` be the length of :math:`z{.}\mathsf{exns}`. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Let :math:`{\mathit{exn}}` be the exception instance :math:`\{ \mathsf{tag}~z{.}\mathsf{module}{.}\mathsf{tags}{}[x],\;\allowbreak \mathsf{fields}~{{\mathit{val}}^{n}} \}`. |
| |
| #. Append :math:`{\mathit{exn}}` to :math:`z{.}\mathsf{exns}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack. |
| |
| #. Execute the instruction :math:`\mathsf{throw\_ref}`. |
| |
| |
| :math:`\mathsf{local{.}set}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Replace :math:`z{.}\mathsf{locals}{}[x]` with :math:`{\mathit{val}}`. |
| |
| |
| :math:`\mathsf{global{.}set}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Replace :math:`z{.}\mathsf{globals}{}[x]{.}\mathsf{value}` with :math:`{\mathit{val}}`. |
| |
| |
| :math:`\mathsf{table{.}set}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i \geq {|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|}`, then: |
| |
| a. Trap. |
| |
| #. Replace :math:`z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i]` with :math:`{\mathit{ref}}`. |
| |
| |
| :math:`\mathsf{table{.}grow}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Assert: Due to validation, a reference value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{ref}}` from the stack. |
| |
| #. Either: |
| |
| a. Let :math:`{\mathit{ti}}` be the table instance :math:`{\mathrm{growtable}}(z{.}\mathsf{tables}{}[x], n, {\mathit{ref}})`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~{|z{.}\mathsf{tables}{}[x]{.}\mathsf{refs}|})` to the stack. |
| |
| #. Replace :math:`z{.}\mathsf{tables}{}[x]` with :math:`{\mathit{ti}}`. |
| |
| #. Or: |
| |
| a. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~{{{{\mathrm{signed}}}_{{|{\mathit{at}}|}}^{{-1}}}}{({-1})})` to the stack. |
| |
| |
| :math:`\mathsf{elem{.}drop}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Replace :math:`z{.}\mathsf{elems}{}[x]{.}\mathsf{refs}` with :math:`\epsilon`. |
| |
| |
| :math:`{{\mathit{nt}}{.}\mathsf{store}}{{{\mathit{storeop}}^?}}~x~{\mathit{ao}}` |
| ................................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{nt}'}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, :math:`{\mathit{nt}} = {\mathit{nt}'}`. |
| |
| #. If :math:`{{\mathit{storeop}}^?}` is not defined, then: |
| |
| a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}'}|} / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathit{nt}'}}(c)`. |
| |
| #. Replace :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}'}|} / 8]` with :math:`{b^\ast}`. |
| |
| #. Else: |
| |
| a. Assert: Due to validation, :math:`{\mathit{nt}'}` is :math:`{\mathsf{i}}{N}`. |
| |
| #. Let :math:`n` be :math:`{{\mathit{storeop}}^?}`. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| 1) Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}({{\mathrm{wrap}}}_{{|{\mathit{nt}'}|}, n}(c))`. |
| |
| #. Replace :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : n / 8]` with :math:`{b^\ast}`. |
| |
| |
| :math:`\mathsf{v{\scriptstyle 128}}{.}\mathsf{store}~x~{\mathit{ao}}` |
| ..................................................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|\mathsf{v{\scriptstyle 128}}|} / 8 > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{\mathsf{v{\scriptstyle 128}}}(c)`. |
| |
| #. Replace :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|\mathsf{v{\scriptstyle 128}}|} / 8]` with :math:`{b^\ast}`. |
| |
| |
| :math:`{\mathsf{v{\scriptstyle 128}}{.}\mathsf{store}}{N}{\mathsf{\_}}{\mathsf{lane}}~x~{\mathit{ao}}~j` |
| ........................................................................................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value of vector type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` from the stack. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + N > {|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then: |
| |
| a. Trap. |
| |
| #. Let :math:`M` be :math:`128 / N`. |
| |
| #. Let :math:`{\mathsf{i}}{N}` be the result for which :math:`{|{\mathsf{i}}{N}|}` :math:`=` :math:`N`. |
| |
| #. Assert: Due to validation, :math:`j < {|{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(c)|}`. |
| |
| #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{N}}({{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(c){}[j])`. |
| |
| #. Replace :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : N / 8]` with :math:`{b^\ast}`. |
| |
| |
| :math:`\mathsf{memory{.}grow}~x` |
| ................................ |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a number value is on the top of the stack. |
| |
| #. Pop the value :math:`({\mathit{at}}{.}\mathsf{const}~n)` from the stack. |
| |
| #. Either: |
| |
| a. Let :math:`{\mathit{mi}}` be the memory instance :math:`{\mathrm{growmem}}(z{.}\mathsf{mems}{}[x], n)`. |
| |
| #. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~{|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|} / (64 \, {\mathrm{Ki}}))` to the stack. |
| |
| #. Replace :math:`z{.}\mathsf{mems}{}[x]` with :math:`{\mathit{mi}}`. |
| |
| #. Or: |
| |
| a. Push the value :math:`({\mathit{at}}{.}\mathsf{const}~{{{{\mathrm{signed}}}_{{|{\mathit{at}}|}}^{{-1}}}}{({-1})})` to the stack. |
| |
| |
| :math:`\mathsf{data{.}drop}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Replace :math:`z{.}\mathsf{datas}{}[x]{.}\mathsf{bytes}` with :math:`\epsilon`. |
| |
| |
| :math:`\mathsf{struct{.}new}~x` |
| ............................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{struct}~{\mathit{list}}({\mathit{fieldtype}})`. |
| |
| #. Let :math:`(\mathsf{struct}~{\mathit{list}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`{({\mathsf{mut}^?}~{\mathit{zt}})^{n}}` be :math:`{\mathit{list}}_0`. |
| |
| #. Let :math:`a` be the length of :math:`z{.}\mathsf{structs}`. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Let :math:`{\mathit{si}}` be the structure instance :math:`\{ \mathsf{type}~z{.}\mathsf{types}{}[x],\;\allowbreak \mathsf{fields}~{{{\mathrm{pack}}}_{{\mathit{zt}}}({\mathit{val}})^{n}} \}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}struct}~a)` to the stack. |
| |
| #. Append :math:`{\mathit{si}}` to :math:`z{.}\mathsf{structs}`. |
| |
| |
| :math:`\mathsf{struct{.}set}~x~i` |
| ................................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}'}` from the stack. |
| |
| #. If :math:`{\mathit{val}'} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}'}` is some :math:`\mathsf{ref{.}struct}~{\mathit{structaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}struct}~a)` be the destructuring of :math:`{\mathit{val}'}`. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{struct}~{\mathit{list}}({\mathit{fieldtype}})`. |
| |
| #. Let :math:`(\mathsf{struct}~{\mathit{list}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`{({\mathsf{mut}^?}~{\mathit{zt}})^\ast}` be :math:`{\mathit{list}}_0`. |
| |
| #. Assert: Due to validation, :math:`i < {|{{\mathit{zt}}^\ast}|}`. |
| |
| #. Replace :math:`z{.}\mathsf{structs}{}[a]{.}\mathsf{fields}{}[i]` with :math:`{{\mathrm{pack}}}_{{{\mathit{zt}}^\ast}{}[i]}({\mathit{val}})`. |
| |
| |
| :math:`\mathsf{array{.}new\_fixed}~x~n` |
| ....................................... |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`. |
| |
| #. Let :math:`(\mathsf{array}~{\mathit{fieldtype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`({\mathsf{mut}^?}~{\mathit{zt}})` be the destructuring of :math:`{\mathit{fieldtype}}_0`. |
| |
| #. Let :math:`a` be the length of :math:`z{.}\mathsf{arrays}`. |
| |
| #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack. |
| |
| #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack. |
| |
| #. Let :math:`{\mathit{ai}}` be the array instance :math:`\{ \mathsf{type}~z{.}\mathsf{types}{}[x],\;\allowbreak \mathsf{fields}~{{{\mathrm{pack}}}_{{\mathit{zt}}}({\mathit{val}})^{n}} \}`. |
| |
| #. Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack. |
| |
| #. Append :math:`{\mathit{ai}}` to :math:`z{.}\mathsf{arrays}`. |
| |
| |
| :math:`\mathsf{array{.}set}~x` |
| .............................. |
| |
| |
| 1. Let :math:`z` be the current state. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Assert: Due to validation, a value of number type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack. |
| |
| #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack. |
| |
| #. Assert: Due to validation, a value is on the top of the stack. |
| |
| #. Pop the value :math:`{\mathit{val}'}` from the stack. |
| |
| #. If :math:`{\mathit{val}'} = \mathsf{ref{.}null}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}'}` is some :math:`\mathsf{ref{.}array}~{\mathit{arrayaddr}}`. |
| |
| #. Let :math:`(\mathsf{ref{.}array}~a)` be the destructuring of :math:`{\mathit{val}'}`. |
| |
| #. If :math:`a < {|z{.}\mathsf{arrays}|}` and :math:`i \geq {|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|}`, then: |
| |
| a. Trap. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`. |
| |
| #. Let :math:`(\mathsf{array}~{\mathit{fieldtype}}_0)` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Let :math:`({\mathsf{mut}^?}~{\mathit{zt}})` be the destructuring of :math:`{\mathit{fieldtype}}_0`. |
| |
| #. Replace :math:`z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}{}[i]` with :math:`{{\mathrm{pack}}}_{{\mathit{zt}}}({\mathit{val}})`. |
| |
| |
| :math:`{\mathrm{min}}(i, j)` |
| ............................ |
| |
| |
| 1. If :math:`i \leq j`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Return :math:`j`. |
| |
| |
| :math:`{\Sigma}\, {{n''}^\ast}` |
| ............................... |
| |
| |
| 1. If :math:`{{n''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`0`. |
| |
| #. Let :math:`n~{{n'}^\ast}` be :math:`{{n''}^\ast}`. |
| |
| #. Return :math:`n + {\Sigma}\, {{n'}^\ast}`. |
| |
| |
| :math:`{\Pi}\, {{n''}^\ast}` |
| ............................ |
| |
| |
| 1. If :math:`{{n''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`1`. |
| |
| #. Let :math:`n~{{n'}^\ast}` be :math:`{{n''}^\ast}`. |
| |
| #. Return :math:`n \cdot {\Pi}\, {{n'}^\ast}`. |
| |
| |
| :math:`{X^\ast}` |
| ................ |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{|{X^\ast}|} = 1`. |
| |
| #. Let :math:`w` be :math:`{X^\ast}`. |
| |
| #. Return :math:`w`. |
| |
| |
| :math:`{\bigoplus}\, {X^\ast}` |
| .............................. |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{w^\ast}~{{{w'}^\ast}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{w^\ast}~{\bigoplus}\, {{{w'}^\ast}^\ast}`. |
| |
| |
| :math:`{\bigoplus}\, {X^\ast}` |
| .............................. |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{w^{n}}~{({{w'}^{n}})^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{w^{n}}~{\bigoplus}\, {({{w'}^{n}})^\ast}`. |
| |
| |
| :math:`{\bigoplus}\, {X^\ast}` |
| .............................. |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{w^?}~{({{w'}^?})^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{w^?}~{\bigoplus}\, {({{w'}^?})^\ast}`. |
| |
| |
| :math:`{X^\ast}~{\mathrm{disjoint}}` |
| .................................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return true. |
| |
| #. Let :math:`w~{{w'}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`w` is not contained in :math:`{{w'}^\ast}` and :math:`{{w'}^\ast}~{\mathrm{disjoint}}`. |
| |
| |
| :math:`{{\mathrm{setminus{\kern-0.1em\scriptstyle 1}}}}_{X}(w, {X^\ast})` |
| ......................................................................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`w`. |
| |
| #. Let :math:`w_1~{{w'}^\ast}` be :math:`{X^\ast}`. |
| |
| #. If :math:`w = w_1`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Return :math:`{{\mathrm{setminus{\kern-0.1em\scriptstyle 1}}}}_{X}(w, {{w'}^\ast})`. |
| |
| |
| :math:`{X^\ast} \setminus {w^\ast}` |
| ................................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`w_1~{{w'}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{{\mathrm{setminus{\kern-0.1em\scriptstyle 1}}}}_{X}(w_1, {w^\ast})~{{w'}^\ast} \setminus {w^\ast}`. |
| |
| |
| :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 2}}}}_{X}(w_1, {X^\ast})` |
| ............................................................................. |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{{w'}^\ast}~{{w^\ast}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`w_1~{{w'}^\ast}~{{\mathrm{setproduct{\kern-0.1em\scriptstyle 2}}}}_{X}(w_1, {{w^\ast}^\ast})`. |
| |
| |
| :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 1}}}}_{X}({X^\ast}, {{w^\ast}^\ast})` |
| ......................................................................................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`w_1~{{w'}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 2}}}}_{X}(w_1, {{w^\ast}^\ast})~{{\mathrm{setproduct{\kern-0.1em\scriptstyle 1}}}}_{X}({{w'}^\ast}, {{w^\ast}^\ast})`. |
| |
| |
| :math:`{\Large\times}~{X^\ast}` |
| ............................... |
| |
| |
| 1. If :math:`{X^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{w_1^\ast}~{{w^\ast}^\ast}` be :math:`{X^\ast}`. |
| |
| #. Return :math:`{{\mathrm{setproduct{\kern-0.1em\scriptstyle 1}}}}_{X}({w_1^\ast}, {\Large\times}~{{w^\ast}^\ast})`. |
| |
| |
| :math:`{\mathrm{signif}}(N)` |
| ............................ |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`23`. |
| |
| #. Assert: Due to validation, :math:`N = 64`. |
| |
| #. Return :math:`52`. |
| |
| |
| :math:`{\mathrm{expon}}(N)` |
| ........................... |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`8`. |
| |
| #. Assert: Due to validation, :math:`N = 64`. |
| |
| #. Return :math:`11`. |
| |
| |
| :math:`M` |
| ......... |
| |
| |
| 1. Return :math:`{\mathrm{signif}}(N)`. |
| |
| |
| :math:`E` |
| ......... |
| |
| |
| 1. Return :math:`{\mathrm{expon}}(N)`. |
| |
| |
| :math:`{+0}` |
| ............ |
| |
| |
| 1. Return :math:`({+((0 + 0 \cdot {2^{{-M}}}) \cdot {2^{e}})})`. |
| |
| |
| :math:`{+n}` |
| ............ |
| |
| |
| 1. Return :math:`({+((1 + n \cdot {2^{{-M}}}) \cdot {2^{0}})})`. |
| |
| |
| :math:`{+1}` |
| ............ |
| |
| |
| 1. Return :math:`({+((1 + 1 \cdot {2^{{-M}}}) \cdot {2^{0}})})`. |
| |
| |
| :math:`{{\mathrm{canon}}}_{N}` |
| .............................. |
| |
| |
| 1. Return :math:`{2^{{\mathrm{signif}}(N) - 1}}`. |
| |
| |
| :math:`{\mathrm{cont}}(b)` |
| .......................... |
| |
| |
| 1. Assert: Due to validation, :math:`128 < b`. |
| |
| #. Assert: Due to validation, :math:`b < 192`. |
| |
| #. Return :math:`b - 128`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externidx}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externidx}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externidx}}_0~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externidx}}_0` is some :math:`\mathsf{func}~{\mathit{funcidx}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~x)` be the destructuring of :math:`{\mathit{externidx}}_0`. |
| |
| #. Return :math:`x~{\mathrm{funcs}}({{\mathit{xx}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externidx}}~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{xx}}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externidx}'}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externidx}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externidx}}_0~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externidx}}_0` is some :math:`\mathsf{global}~{\mathit{globalidx}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~x)` be the destructuring of :math:`{\mathit{externidx}}_0`. |
| |
| #. Return :math:`x~{\mathrm{globals}}({{\mathit{xx}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externidx}}~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{xx}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externidx}'}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externidx}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externidx}}_0~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externidx}}_0` is some :math:`\mathsf{table}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~x)` be the destructuring of :math:`{\mathit{externidx}}_0`. |
| |
| #. Return :math:`x~{\mathrm{tables}}({{\mathit{xx}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externidx}}~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{xx}}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externidx}'}^\ast})` |
| ..................................................... |
| |
| |
| 1. If :math:`{{\mathit{externidx}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externidx}}_0~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externidx}}_0` is some :math:`\mathsf{mem}~{\mathit{memidx}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~x)` be the destructuring of :math:`{\mathit{externidx}}_0`. |
| |
| #. Return :math:`x~{\mathrm{mems}}({{\mathit{xx}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externidx}}~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{xx}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tags}}({{\mathit{externidx}'}^\ast})` |
| ..................................................... |
| |
| |
| 1. If :math:`{{\mathit{externidx}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externidx}}_0~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externidx}}_0` is some :math:`\mathsf{tag}~{\mathit{tagidx}}`, then: |
| |
| a. Let :math:`(\mathsf{tag}~x)` be the destructuring of :math:`{\mathit{externidx}}_0`. |
| |
| #. Return :math:`x~{\mathrm{tags}}({{\mathit{xx}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externidx}}~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tags}}({{\mathit{xx}}^\ast})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{opt}}({{\mathit{free}'}^?})` |
| ............................................................ |
| |
| |
| 1. If :math:`{{\mathit{free}'}^?}` is not defined, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. Let :math:`{\mathit{free}}` be :math:`{{\mathit{free}'}^?}`. |
| |
| #. Return :math:`{\mathit{free}}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{list}}({{\mathit{free}''}^\ast})` |
| ................................................................. |
| |
| |
| 1. If :math:`{{\mathit{free}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. Let :math:`{\mathit{free}}~{{\mathit{free}'}^\ast}` be :math:`{{\mathit{free}''}^\ast}`. |
| |
| #. Return `free ++ $free_list(free'*{free' <- free'*})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})` |
| .............................................................. |
| |
| |
| 1. Return :math:`\{ \mathsf{types}~{\mathit{typeidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{funcidx}}({\mathit{funcidx}})` |
| .............................................................. |
| |
| |
| 1. Return :math:`\{ \mathsf{funcs}~{\mathit{funcidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{globalidx}}({\mathit{globalidx}})` |
| .................................................................. |
| |
| |
| 1. Return :math:`\{ \mathsf{globals}~{\mathit{globalidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`\{ \mathsf{tables}~{\mathit{tableidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{memidx}}({\mathit{memidx}})` |
| ............................................................ |
| |
| |
| 1. Return :math:`\{ \mathsf{mems}~{\mathit{memidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{elemidx}}({\mathit{elemidx}})` |
| .............................................................. |
| |
| |
| 1. Return :math:`\{ \mathsf{elems}~{\mathit{elemidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{dataidx}}({\mathit{dataidx}})` |
| .............................................................. |
| |
| |
| 1. Return :math:`\{ \mathsf{datas}~{\mathit{dataidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{localidx}}({\mathit{localidx}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`\{ \mathsf{locals}~{\mathit{localidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{labelidx}}({\mathit{labelidx}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`\{ \mathsf{labels}~{\mathit{labelidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{tagidx}}({\mathit{tagidx}})` |
| ............................................................ |
| |
| |
| 1. Return :math:`\{ \mathsf{tags}~{\mathit{tagidx}} \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{externidx}}({\mathit{externidx}})` |
| .................................................................. |
| |
| |
| 1. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{func}~{\mathit{funcidx}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{funcidx}})` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{funcidx}}({\mathit{funcidx}})`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{global}~{\mathit{globalidx}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{globalidx}})` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{globalidx}}({\mathit{globalidx}})`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{table}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tableidx}})` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}})`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{mem}~{\mathit{memidx}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{memidx}})` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{memidx}}({\mathit{memidx}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{externidx}}` is some :math:`\mathsf{tag}~{\mathit{tagidx}}`. |
| |
| #. Let :math:`(\mathsf{tag}~{\mathit{tagidx}})` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tagidx}}({\mathit{tagidx}})`. |
| |
| |
| :math:`\mathsf{anyref}` |
| ....................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{any})`. |
| |
| |
| :math:`\mathsf{eqref}` |
| ...................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{eq})`. |
| |
| |
| :math:`\mathsf{i{\scriptstyle 31}ref}` |
| ...................................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{i{\scriptstyle 31}})`. |
| |
| |
| :math:`\mathsf{structref}` |
| .......................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{struct})`. |
| |
| |
| :math:`\mathsf{arrayref}` |
| ......................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{array})`. |
| |
| |
| :math:`\mathsf{funcref}` |
| ........................ |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{func})`. |
| |
| |
| :math:`\mathsf{exnref}` |
| ....................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{exn})`. |
| |
| |
| :math:`\mathsf{externref}` |
| .......................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{extern})`. |
| |
| |
| :math:`\mathsf{nullref}` |
| ........................ |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{none})`. |
| |
| |
| :math:`\mathsf{nullfuncref}` |
| ............................ |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{nofunc})`. |
| |
| |
| :math:`\mathsf{nullexnref}` |
| ........................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{noexn})`. |
| |
| |
| :math:`\mathsf{nullexternref}` |
| .............................. |
| |
| |
| 1. Return :math:`(\mathsf{ref}~\mathsf{null}~\mathsf{noextern})`. |
| |
| |
| :math:`{\mathsf{i}}{N}` |
| ....................... |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| #. Assert: Due to validation, :math:`N = 64`. |
| |
| #. Return :math:`\mathsf{i{\scriptstyle 64}}`. |
| |
| |
| :math:`{\mathsf{f}}{N}` |
| ....................... |
| |
| |
| 1. If :math:`N = 32`, then: |
| |
| a. Return :math:`\mathsf{f{\scriptstyle 32}}`. |
| |
| #. Assert: Due to validation, :math:`N = 64`. |
| |
| #. Return :math:`\mathsf{f{\scriptstyle 64}}`. |
| |
| |
| :math:`{\mathsf{i}}{N}` |
| ....................... |
| |
| |
| 1. If :math:`N = 8`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 8}}`. |
| |
| #. If :math:`N = 16`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 16}}`. |
| |
| #. If :math:`N = 32`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| #. Assert: Due to validation, :math:`N = 64`. |
| |
| #. Return :math:`\mathsf{i{\scriptstyle 64}}`. |
| |
| |
| :math:`{|{\mathit{numtype}}|}` |
| .............................. |
| |
| |
| 1. If :math:`{\mathit{numtype}} = \mathsf{i{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`32`. |
| |
| #. If :math:`{\mathit{numtype}} = \mathsf{i{\scriptstyle 64}}`, then: |
| |
| a. Return :math:`64`. |
| |
| #. If :math:`{\mathit{numtype}} = \mathsf{f{\scriptstyle 32}}`, then: |
| |
| a. Return :math:`32`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}} = \mathsf{f{\scriptstyle 64}}`. |
| |
| #. Return :math:`64`. |
| |
| |
| :math:`{|\mathsf{v{\scriptstyle 128}}|}` |
| ........................................ |
| |
| |
| 1. Return :math:`128`. |
| |
| |
| :math:`{|{\mathit{packtype}}|}` |
| ............................... |
| |
| |
| 1. If :math:`{\mathit{packtype}} = \mathsf{i{\scriptstyle 8}}`, then: |
| |
| a. Return :math:`8`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{packtype}} = \mathsf{i{\scriptstyle 16}}`. |
| |
| #. Return :math:`16`. |
| |
| |
| :math:`{|{\mathit{lanetype}}|}` |
| ............................... |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`{|{\mathit{lanetype}}|}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`{|{\mathit{lanetype}}|}`. |
| |
| |
| :math:`{|{\mathit{storagetype}}|}` |
| .................................. |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is number type, then: |
| |
| a. Return :math:`{|{\mathit{storagetype}}|}`. |
| |
| #. If :math:`{\mathit{storagetype}}` is vector type, then: |
| |
| a. Return :math:`{|{\mathit{storagetype}}|}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Return :math:`{|{\mathit{storagetype}}|}`. |
| |
| |
| :math:`{|{\mathsf{i}}{N}|}` |
| ........................... |
| |
| |
| 1. Return :math:`{|{\mathsf{i}}{N}|}`. |
| |
| |
| :math:`{|{\mathsf{i}}{N}|}` |
| ........................... |
| |
| |
| 1. Return :math:`{|{\mathsf{i}}{N}|}`. |
| |
| |
| :math:`{|{\mathsf{f}}{N}|}` |
| ........................... |
| |
| |
| 1. Return :math:`{|{\mathsf{f}}{N}|}`. |
| |
| |
| :math:`{\mathrm{inv}}_{\mathit{isize}}(n)` |
| .......................................... |
| |
| |
| 1. If :math:`n = 32`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| #. If :math:`n = 64`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 64}}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{inv}}_{\mathit{jsize}}(n)` |
| .......................................... |
| |
| |
| 1. If :math:`n = 8`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 8}}`. |
| |
| #. If :math:`n = 16`, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 16}}`. |
| |
| #. Return :math:`{\mathrm{inv}}_{\mathit{isize}}(n)`. |
| |
| |
| :math:`{\mathrm{inv}}_{\mathit{fsize}}(n)` |
| .......................................... |
| |
| |
| 1. If :math:`n = 32`, then: |
| |
| a. Return :math:`\mathsf{f{\scriptstyle 32}}`. |
| |
| #. If :math:`n = 64`, then: |
| |
| a. Return :math:`\mathsf{f{\scriptstyle 64}}`. |
| |
| #. Fail. |
| |
| |
| :math:`N` |
| ......... |
| |
| |
| 1. Return :math:`{|{\mathit{nt}}|}`. |
| |
| |
| :math:`N_1` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{nt}}|}`. |
| |
| |
| :math:`N_2` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{nt}}|}`. |
| |
| |
| :math:`N` |
| ......... |
| |
| |
| 1. Return :math:`{|{\mathit{vt}}|}`. |
| |
| |
| :math:`N` |
| ......... |
| |
| |
| 1. Return :math:`{|{\mathit{pt}}|}`. |
| |
| |
| :math:`N` |
| ......... |
| |
| |
| 1. Return :math:`{|{\mathit{lt}}|}`. |
| |
| |
| :math:`N_1` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{lt}}|}`. |
| |
| |
| :math:`N_2` |
| ........... |
| |
| |
| 1. Return :math:`{|{\mathit{lt}}|}`. |
| |
| |
| :math:`N` |
| ......... |
| |
| |
| 1. Return :math:`{|{\mathsf{i}}{N}|}`. |
| |
| |
| :math:`{\mathrm{inv}}_{\mathit{jsizenn}}(n)` |
| ............................................ |
| |
| |
| 1. Return :math:`{\mathrm{inv}}_{\mathit{jsize}}(n)`. |
| |
| |
| :math:`{\mathrm{unpack}}({\mathit{lanetype}})` |
| .............................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`{\mathit{lanetype}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| :math:`{\mathrm{unpack}}({\mathit{storagetype}})` |
| ................................................. |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is value type, then: |
| |
| a. Return :math:`{\mathit{storagetype}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| |
| :math:`{\mathrm{unpack}}({\mathit{storagetype}})` |
| ................................................. |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is number type, then: |
| |
| a. Return :math:`{\mathit{storagetype}}`. |
| |
| #. If :math:`{\mathit{storagetype}}` is packed type, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{unpack}}({\mathit{vectype}})` |
| ............................................. |
| |
| |
| 1. Return :math:`{\mathit{vectype}}`. |
| |
| |
| :math:`{\mathrm{unpack}}({\mathit{storagetype}})` |
| ................................................. |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is constant type, then: |
| |
| a. Return :math:`{\mathit{storagetype}}`. |
| |
| #. If :math:`{\mathit{storagetype}}` is packed type, then: |
| |
| a. Return :math:`\mathsf{i{\scriptstyle 32}}`. |
| |
| #. If :math:`{\mathit{storagetype}}` is lane type, then: |
| |
| a. Return :math:`{\mathrm{unpack}}({\mathit{storagetype}})`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{min}}({\mathit{at}}_1, {\mathit{at}}_2)` |
| ........................................................ |
| |
| |
| 1. If :math:`{|{\mathit{at}}_1|} \leq {|{\mathit{at}}_2|}`, then: |
| |
| a. Return :math:`{\mathit{at}}_1`. |
| |
| #. Return :math:`{\mathit{at}}_2`. |
| |
| |
| :math:`\mathsf{ref}~{{\mathsf{null}}_1^?}~{\mathit{ht}}_1 \setminus \mathsf{ref}~{\mathsf{null}^?}~{\mathit{ht}}_2` |
| ................................................................................................................... |
| |
| |
| 1. If :math:`{\mathsf{null}^?} = \mathsf{null}`, then: |
| |
| a. Return :math:`(\mathsf{ref}~{\mathit{ht}}_1)`. |
| |
| #. Assert: Due to validation, :math:`{\mathsf{null}^?}` is not defined. |
| |
| #. Return :math:`(\mathsf{ref}~{{\mathsf{null}}_1^?}~{\mathit{ht}}_1)`. |
| |
| |
| :math:`{\mathit{dt}}` |
| ..................... |
| |
| |
| 1. Return :math:`{\mathit{dt}}`. |
| |
| |
| :math:`{\mathrm{tags}}({{\mathit{externtype}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{tag}~{\mathit{tagtype}}`, then: |
| |
| a. Let :math:`(\mathsf{tag}~{\mathit{jt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{jt}}~{\mathrm{tags}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tags}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externtype}'}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{global}~{\mathit{globaltype}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{gt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{gt}}~{\mathrm{globals}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externtype}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{mem}~{\mathit{memtype}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{mt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{mt}}~{\mathrm{mems}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externtype}'}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{table}~{\mathit{tabletype}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{tt}}~{\mathrm{tables}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externtype}'}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externtype}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externtype}}_0` is some :math:`\mathsf{func}~{\mathit{typeuse}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~{\mathit{dt}})` be the destructuring of :math:`{\mathit{externtype}}_0`. |
| |
| #. Return :math:`{\mathit{dt}}~{\mathrm{funcs}}({{\mathit{xt}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{xt}}^\ast})`. |
| |
| |
| :math:`{{\mathit{tv}}}{{}[ {{\mathit{typevar}}^\ast} := {{\mathit{typeuse}}^\ast} ]}` |
| ..................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{typeuse}}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{\mathit{typevar}}^\ast} = \epsilon`. |
| |
| #. Return :math:`{\mathit{tv}}`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{tu}}_1~{{\mathit{tu}'}^\ast}` be :math:`{{\mathit{typeuse}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{typevar}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{tv}}_1~{{\mathit{tv}'}^\ast}` be :math:`{{\mathit{typevar}}^\ast}`. |
| |
| #. If :math:`{\mathit{tv}} = {\mathit{tv}}_1`, then: |
| |
| 1) Return :math:`{\mathit{tu}}_1`. |
| |
| #. Return :math:`{{\mathit{tv}}}{{}[ {{\mathit{tv}'}^\ast} := {{\mathit{tu}'}^\ast} ]}`. |
| |
| |
| :math:`{\mathrm{minus}}_{\mathit{recs}}({{\mathit{typevar}}^\ast}, {{\mathit{typeuse}}^\ast})` |
| .............................................................................................. |
| |
| |
| 1. If :math:`{{\mathit{typevar}}^\ast} = \epsilon`, then: |
| |
| a. If :math:`{{\mathit{typeuse}}^\ast} = \epsilon`, then: |
| |
| 1) Return :math:`(\epsilon, \epsilon)`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{typevar}}_0~{{\mathit{tv}}^\ast}` be :math:`{{\mathit{typevar}}^\ast}`. |
| |
| #. If :math:`{\mathit{typevar}}_0` is some :math:`\mathsf{rec} {.} n` and :math:`{|{{\mathit{typeuse}}^\ast}|} \geq 1`, then: |
| |
| 1) Let :math:`{\mathit{tu}}_1~{{\mathit{tu}}^\ast}` be :math:`{{\mathit{typeuse}}^\ast}`. |
| |
| #) Return :math:`{\mathrm{minus}}_{\mathit{recs}}({{\mathit{tv}}^\ast}, {{\mathit{tu}}^\ast})`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{typeuse}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{tu}}_1~{{\mathit{tu}}^\ast}` be :math:`{{\mathit{typeuse}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{typevar}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{typevar}}_0~{{\mathit{tv}}^\ast}` be :math:`{{\mathit{typevar}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{typevar}}_0` is some :math:`{\mathit{typeidx}}`. |
| |
| #. Let :math:`x` be the type variable :math:`{\mathit{typevar}}_0`. |
| |
| #. Let :math:`({{\mathit{tv}'}^\ast}, {{\mathit{tu}'}^\ast})` be the destructuring of :math:`{\mathrm{minus}}_{\mathit{recs}}({{\mathit{tv}}^\ast}, {{\mathit{tu}}^\ast})`. |
| |
| #. Return :math:`(x~{{\mathit{tv}'}^\ast}, {\mathit{tu}}_1~{{\mathit{tu}'}^\ast})`. |
| |
| |
| :math:`{{\mathit{pt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ........................................................................... |
| |
| |
| 1. Return :math:`{\mathit{pt}}`. |
| |
| |
| :math:`{{\mathit{nt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ........................................................................... |
| |
| |
| 1. Return :math:`{\mathit{nt}}`. |
| |
| |
| :math:`{{\mathit{vt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ........................................................................... |
| |
| |
| 1. Return :math:`{\mathit{vt}}`. |
| |
| |
| :math:`{{\mathit{typeuse}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................ |
| |
| |
| 1. If :math:`{\mathit{typeuse}}` is type variable, then: |
| |
| a. Return :math:`{{\mathit{typeuse}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{typeuse}}` is defined type. |
| |
| #. Return :math:`{{\mathit{typeuse}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| |
| :math:`{{\mathit{heaptype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................. |
| |
| |
| 1. If :math:`{\mathit{heaptype}}` is type variable, then: |
| |
| a. Return :math:`{{\mathit{heaptype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| #. If :math:`{\mathit{heaptype}}` is defined type, then: |
| |
| a. Return :math:`{{\mathit{heaptype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| #. Return :math:`{\mathit{heaptype}}`. |
| |
| |
| :math:`{\mathsf{ref}~{\mathsf{null}^?}~{\mathit{ht}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| .......................................................................................................... |
| |
| |
| 1. Return :math:`(\mathsf{ref}~{\mathsf{null}^?}~{{\mathit{ht}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| |
| :math:`{{\mathit{valtype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................ |
| |
| |
| 1. If :math:`{\mathit{valtype}}` is number type, then: |
| |
| a. Return :math:`{{\mathit{valtype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| #. If :math:`{\mathit{valtype}}` is vector type, then: |
| |
| a. Return :math:`{{\mathit{valtype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| #. If :math:`{\mathit{valtype}}` is reference type, then: |
| |
| a. Return :math:`{{\mathit{valtype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}} = \mathsf{bot}`. |
| |
| #. Return :math:`\mathsf{bot}`. |
| |
| |
| :math:`{{\mathit{storagetype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| .................................................................................... |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is value type, then: |
| |
| a. Return :math:`{{\mathit{storagetype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Return :math:`{{\mathit{storagetype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| |
| :math:`{{\mathsf{mut}^?}~{\mathit{zt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ............................................................................................ |
| |
| |
| 1. Return :math:`({\mathsf{mut}^?}~{{\mathit{zt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| |
| :math:`{{\mathit{comptype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................. |
| |
| |
| 1. If :math:`{\mathit{comptype}}` is some :math:`\mathsf{struct}~{\mathit{list}}({\mathit{fieldtype}})`, then: |
| |
| a. Let :math:`(\mathsf{struct}~{{\mathit{ft}}^\ast})` be the destructuring of :math:`{\mathit{comptype}}`. |
| |
| #. Return :math:`(\mathsf{struct}~{{{\mathit{ft}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}^\ast})`. |
| |
| #. If :math:`{\mathit{comptype}}` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`, then: |
| |
| a. Let :math:`(\mathsf{array}~{\mathit{ft}})` be the destructuring of :math:`{\mathit{comptype}}`. |
| |
| #. Return :math:`(\mathsf{array}~{{\mathit{ft}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{comptype}}` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})` be the destructuring of :math:`{\mathit{comptype}}`. |
| |
| #. Return :math:`(\mathsf{func}~{{t_1}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}^\ast}~\rightarrow~{{t_2}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}^\ast})`. |
| |
| |
| :math:`{\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{tu}'}^\ast}~{\mathit{ct}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................................................................. |
| |
| |
| 1. Return :math:`(\mathsf{sub}~{\mathsf{final}^?}~{{{\mathit{tu}'}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}^\ast}~{{\mathit{ct}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| |
| :math:`{\mathsf{rec}~{{\mathit{st}}^\ast}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ............................................................................................... |
| |
| |
| 1. Let :math:`({{\mathit{tv}'}^\ast}, {{\mathit{tu}'}^\ast})` be the destructuring of :math:`{\mathrm{minus}}_{\mathit{recs}}({{\mathit{tv}}^\ast}, {{\mathit{tu}}^\ast})`. |
| |
| #. Return :math:`(\mathsf{rec}~{{{\mathit{st}}}{{}[ {{\mathit{tv}'}^\ast} := {{\mathit{tu}'}^\ast} ]}^\ast})`. |
| |
| |
| :math:`{{\mathit{qt}} {.} i}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................. |
| |
| |
| 1. Return :math:`({{\mathit{qt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]} {.} i)`. |
| |
| |
| :math:`{{\mathit{at}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ........................................................................... |
| |
| |
| 1. Return :math:`{\mathit{at}}`. |
| |
| |
| :math:`{{\mathit{tu}'}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ............................................................................ |
| |
| |
| 1. Return :math:`{{\mathit{tu}'}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}`. |
| |
| |
| :math:`{{\mathsf{mut}^?}~t}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................ |
| |
| |
| 1. Return :math:`({\mathsf{mut}^?}~{t}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| |
| :math:`{{\mathit{at}}~{\mathit{lim}}~\mathsf{page}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ........................................................................................................ |
| |
| |
| 1. Return :math:`({\mathit{at}}~{\mathit{lim}}~\mathsf{page})`. |
| |
| |
| :math:`{{\mathit{at}}~{\mathit{lim}}~{\mathit{rt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ........................................................................................................ |
| |
| |
| 1. Return :math:`({\mathit{at}}~{\mathit{lim}}~{{\mathit{rt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| |
| :math:`{{\mathit{externtype}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ................................................................................... |
| |
| |
| 1. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{tag}~{\mathit{tagtype}}`, then: |
| |
| a. Let :math:`(\mathsf{tag}~{\mathit{jt}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`(\mathsf{tag}~{{\mathit{jt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| #. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{global}~{\mathit{globaltype}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{gt}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`(\mathsf{global}~{{\mathit{gt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| #. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{table}~{\mathit{tabletype}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tt}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`(\mathsf{table}~{{\mathit{tt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| #. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{mem}~{\mathit{memtype}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{mt}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`(\mathsf{mem}~{{\mathit{mt}}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{externtype}}` is some :math:`\mathsf{func}~{\mathit{typeuse}}`. |
| |
| #. Let :math:`(\mathsf{func}~{\mathit{tu}'})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`(\mathsf{func}~{{\mathit{tu}'}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]})`. |
| |
| |
| :math:`{{{\mathit{xt}}_1^\ast}~\rightarrow~{{\mathit{xt}}_2^\ast}}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}` |
| ....................................................................................................................... |
| |
| |
| 1. Return :math:`{{{\mathit{xt}}_1}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}^\ast}~\rightarrow~{{{\mathit{xt}}_2}{{}[ {{\mathit{tv}}^\ast} := {{\mathit{tu}}^\ast} ]}^\ast}`. |
| |
| |
| :math:`{t}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ............................................. |
| |
| |
| 1. Return :math:`{t}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{rt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{rt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{dt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{dt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{jt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{jt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{gt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{gt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{mt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{mt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{tt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{tt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{xt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| ......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{xt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{\mathit{mmt}}}{{}[ {:=}\, {{\mathit{tu}}^{n}} ]}` |
| .......................................................... |
| |
| |
| 1. Return :math:`{{\mathit{mmt}}}{{}[ {i^{i<n}} := {{\mathit{tu}}^{n}} ]}`. |
| |
| |
| :math:`{{{\mathit{deftype}}^\ast}}{{}[ {:=}\, {{\mathit{tu}}^\ast} ]}` |
| ...................................................................... |
| |
| |
| 1. If :math:`{{\mathit{deftype}}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{dt}}_1~{{\mathit{dt}}^\ast}` be :math:`{{\mathit{deftype}}^\ast}`. |
| |
| #. Return :math:`{{\mathit{dt}}_1}{{}[ {:=}\, {{\mathit{tu}}^\ast} ]}~{{{\mathit{dt}}^\ast}}{{}[ {:=}\, {{\mathit{tu}}^\ast} ]}`. |
| |
| |
| :math:`{{\mathrm{roll}}}_{x}({\mathit{rectype}})` |
| ................................................. |
| |
| |
| 1. Let :math:`(\mathsf{rec}~{{\mathit{subtype}}^{n}})` be the destructuring of :math:`{\mathit{rectype}}`. |
| |
| #. Return :math:`(\mathsf{rec}~{{{\mathit{subtype}}}{{}[ {x + i^{i<n}} := {(\mathsf{rec} {.} i)^{i<n}} ]}^{n}})`. |
| |
| |
| :math:`{\mathrm{unroll}}({\mathit{rectype}})` |
| ............................................. |
| |
| |
| 1. Let :math:`(\mathsf{rec}~{{\mathit{subtype}}^{n}})` be the destructuring of :math:`{\mathit{rectype}}`. |
| |
| #. Return :math:`(\mathsf{rec}~{{{\mathit{subtype}}}{{}[ {(\mathsf{rec} {.} i)^{i<n}} := {({\mathit{rectype}} {.} i)^{i<n}} ]}^{n}})`. |
| |
| |
| :math:`{{{{\mathrm{roll}}}_{x}^\ast}}{({\mathit{rectype}})}` |
| ............................................................ |
| |
| |
| 1. Let :math:`(\mathsf{rec}~{{\mathit{subtype}}^{n}})` be the destructuring of :math:`{{\mathrm{roll}}}_{x}({\mathit{rectype}})`. |
| |
| #. Return :math:`{((\mathsf{rec}~{{\mathit{subtype}}^{n}}) {.} i)^{i<n}}`. |
| |
| |
| :math:`{\mathrm{unroll}}({\mathit{rectype}} {.} i)` |
| ................................................... |
| |
| |
| 1. Let :math:`(\mathsf{rec}~{{\mathit{subtype}}^\ast})` be the destructuring of :math:`{\mathrm{unroll}}({\mathit{rectype}})`. |
| |
| #. Return :math:`{{\mathit{subtype}}^\ast}{}[i]`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{addrtype}}({\mathit{addrtype}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{numtype}})` |
| .............................................................. |
| |
| |
| 1. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{packtype}}({\mathit{packtype}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{lanetype}}({\mathit{lanetype}})` |
| ................................................................ |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{lanetype}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{packtype}}({\mathit{lanetype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{vectype}})` |
| .............................................................. |
| |
| |
| 1. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{consttype}}({\mathit{consttype}})` |
| .................................................................. |
| |
| |
| 1. If :math:`{\mathit{consttype}}` is number type, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{consttype}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{consttype}}` is vector type. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{consttype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{absheaptype}}({\mathit{absheaptype}})` |
| ...................................................................... |
| |
| |
| 1. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{typevar}}({\mathit{typevar}})` |
| .............................................................. |
| |
| |
| 1. If :math:`{\mathit{typevar}}` is some :math:`{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`{\mathit{typeidx}}` be the type variable :math:`{\mathit{typevar}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{typevar}}` is some :math:`\mathsf{rec} {.} n`. |
| |
| #. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{heaptype}}({\mathit{heaptype}})` |
| ................................................................ |
| |
| |
| 1. If :math:`{\mathit{heaptype}}` is abstract heap type, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{absheaptype}}({\mathit{heaptype}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{heaptype}}` is type use. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeuse}}({\mathit{heaptype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{reftype}}(\mathsf{ref}~{\mathsf{null}^?}~{\mathit{heaptype}})` |
| .............................................................................................. |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{heaptype}}({\mathit{heaptype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{typeuse}}({\mathit{typeuse}})` |
| .............................................................. |
| |
| |
| 1. If :math:`{\mathit{typeuse}}` is type variable, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{typevar}}({\mathit{typeuse}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{typeuse}}` is defined type. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{deftype}}({\mathit{typeuse}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{valtype}}({\mathit{valtype}})` |
| .............................................................. |
| |
| |
| 1. If :math:`{\mathit{valtype}}` is number type, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{valtype}})`. |
| |
| #. If :math:`{\mathit{valtype}}` is vector type, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{valtype}})`. |
| |
| #. If :math:`{\mathit{valtype}}` is reference type, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{reftype}}({\mathit{valtype}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}} = \mathsf{bot}`. |
| |
| #. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{resulttype}}({{\mathit{valtype}}^\ast})` |
| ........................................................................ |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{valtype}}({\mathit{valtype}})^\ast})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{storagetype}}({\mathit{storagetype}})` |
| ...................................................................... |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is value type, then: |
| |
| a. Return :math:`{\mathrm{free}}_{\mathit{valtype}}({\mathit{storagetype}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{packtype}}({\mathit{storagetype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{fieldtype}}({\mathsf{mut}^?}~{\mathit{storagetype}})` |
| ..................................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{storagetype}}({\mathit{storagetype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{comptype}}({\mathit{comptype}})` |
| ................................................................ |
| |
| |
| 1. If :math:`{\mathit{comptype}}` is some :math:`\mathsf{struct}~{\mathit{list}}({\mathit{fieldtype}})`, then: |
| |
| a. Let :math:`(\mathsf{struct}~{{\mathit{fieldtype}}^\ast})` be the destructuring of :math:`{\mathit{comptype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{fieldtype}}({\mathit{fieldtype}})^\ast})`. |
| |
| #. If :math:`{\mathit{comptype}}` is some :math:`\mathsf{array}~{\mathit{fieldtype}}`, then: |
| |
| a. Let :math:`(\mathsf{array}~{\mathit{fieldtype}})` be the destructuring of :math:`{\mathit{comptype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{fieldtype}}({\mathit{fieldtype}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{comptype}}` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{\mathit{resulttype}}_1~\rightarrow~{\mathit{resulttype}}_2)` be the destructuring of :math:`{\mathit{comptype}}`. |
| |
| #. Return `$free_resulttype(resulttype_1) ++ $free_resulttype(resulttype_2)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{subtype}}(\mathsf{sub}~{\mathsf{final}^?}~{{\mathit{typeuse}}^\ast}~{\mathit{comptype}})` |
| ......................................................................................................................... |
| |
| |
| 1. Return `$free_list($free_typeuse(typeuse)*{typeuse <- typeuse*}) ++ $free_comptype(comptype)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{rectype}}(\mathsf{rec}~{{\mathit{subtype}}^\ast})` |
| .................................................................................. |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{subtype}}({\mathit{subtype}})^\ast})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{deftype}}({\mathit{rectype}} {.} n)` |
| .................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{rectype}}({\mathit{rectype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{tagtype}}({\mathit{deftype}})` |
| .............................................................. |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{deftype}}({\mathit{deftype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{globaltype}}({\mathsf{mut}^?}~{\mathit{valtype}})` |
| .................................................................................. |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{valtype}}({\mathit{valtype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{memtype}}({\mathit{addrtype}}~{\mathit{limits}}~\mathsf{page})` |
| ............................................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{addrtype}}({\mathit{addrtype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{tabletype}}({\mathit{addrtype}}~{\mathit{limits}}~{\mathit{reftype}})` |
| ...................................................................................................... |
| |
| |
| 1. Return `$free_addrtype(addrtype) ++ $free_reftype(reftype)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{datatype}}(\mathsf{ok})` |
| ........................................................ |
| |
| |
| 1. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{elemtype}}({\mathit{reftype}})` |
| ............................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{reftype}}({\mathit{reftype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{externtype}}({\mathit{externtype}})` |
| .................................................................... |
| |
| |
| 1. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{tag}~{\mathit{tagtype}}`, then: |
| |
| a. Let :math:`(\mathsf{tag}~{\mathit{tagtype}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tagtype}}({\mathit{tagtype}})`. |
| |
| #. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{global}~{\mathit{globaltype}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{globaltype}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{globaltype}}({\mathit{globaltype}})`. |
| |
| #. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{mem}~{\mathit{memtype}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~{\mathit{memtype}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{memtype}}({\mathit{memtype}})`. |
| |
| #. If :math:`{\mathit{externtype}}` is some :math:`\mathsf{table}~{\mathit{tabletype}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tabletype}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tabletype}}({\mathit{tabletype}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{externtype}}` is some :math:`\mathsf{func}~{\mathit{typeuse}}`. |
| |
| #. Let :math:`(\mathsf{func}~{\mathit{typeuse}})` be the destructuring of :math:`{\mathit{externtype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeuse}}({\mathit{typeuse}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{moduletype}}({{\mathit{externtype}}_1^\ast}~\rightarrow~{{\mathit{externtype}}_2^\ast})` |
| ........................................................................................................................ |
| |
| |
| 1. Return `$free_list($free_externtype(externtype_1)*{externtype_1 <- externtype_1*}) ++ $free_list($free_externtype(externtype_2)*{externtype_2 <- externtype_2*})`. |
| |
| |
| :math:`{\mathrm{dim}}({{\mathsf{i}}{N}}{\mathsf{x}}{M})` |
| ........................................................ |
| |
| |
| 1. Return :math:`M`. |
| |
| |
| :math:`{\mathrm{lanetype}}({{\mathsf{i}}{N}}{\mathsf{x}}{M})` |
| ............................................................. |
| |
| |
| 1. Return :math:`{\mathsf{i}}{N}`. |
| |
| |
| :math:`{\mathrm{unpack}}({{\mathsf{i}}{N}}{\mathsf{x}}{M})` |
| ........................................................... |
| |
| |
| 1. Return :math:`{\mathrm{unpack}}({\mathsf{i}}{N})`. |
| |
| |
| |
| |
| |
| |
| 1. Return :math:`\{ \mathsf{align}~0,\;\allowbreak \mathsf{offset}~0 \}`. |
| |
| |
| :math:`{\mathit{consttype}}{.}\mathsf{const}~c` |
| ............................................... |
| |
| |
| 1. If :math:`{\mathit{consttype}}` is number type, then: |
| |
| a. Return :math:`({\mathit{consttype}}{.}\mathsf{const}~c)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{consttype}}` is vector type. |
| |
| #. Return :math:`({\mathit{consttype}}{.}\mathsf{const}~c)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{shape}}({{\mathit{lanetype}}}{\mathsf{x}}{{\mathit{dim}}})` |
| ........................................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{lanetype}}({\mathit{lanetype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{blocktype}}({\mathit{blocktype}})` |
| .................................................................. |
| |
| |
| 1. If :math:`{\mathit{blocktype}}` is some :math:`{{\mathit{valtype}}^?}`, then: |
| |
| a. Let :math:`{{\mathit{valtype}}^?}` be the block type :math:`{\mathit{blocktype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{opt}}({{\mathrm{free}}_{\mathit{valtype}}({\mathit{valtype}})^?})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{blocktype}}` is some :math:`{\mathit{typeidx}}`. |
| |
| #. Let :math:`{\mathit{typeidx}}` be the block type :math:`{\mathit{blocktype}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{catch}}({\mathit{catch}})` |
| .......................................................... |
| |
| |
| 1. If :math:`{\mathit{catch}}` is some :math:`\mathsf{catch}~{\mathit{tagidx}}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{catch}~{\mathit{tagidx}}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{catch}}`. |
| |
| #. Return `$free_tagidx(tagidx) ++ $free_labelidx(labelidx)`. |
| |
| #. If :math:`{\mathit{catch}}` is some :math:`\mathsf{catch\_ref}~{\mathit{tagidx}}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{catch\_ref}~{\mathit{tagidx}}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{catch}}`. |
| |
| #. Return `$free_tagidx(tagidx) ++ $free_labelidx(labelidx)`. |
| |
| #. If :math:`{\mathit{catch}}` is some :math:`\mathsf{catch\_all}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{catch\_all}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{catch}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{labelidx}}({\mathit{labelidx}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{catch}}` is some :math:`\mathsf{catch\_all\_ref}~{\mathit{labelidx}}`. |
| |
| #. Let :math:`(\mathsf{catch\_all\_ref}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{catch}}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{labelidx}}({\mathit{labelidx}})`. |
| |
| |
| :math:`{\mathrm{shift}}_{\mathit{labelidxs}}({{\mathit{labelidx}''}^\ast})` |
| ........................................................................... |
| |
| |
| 1. If :math:`{{\mathit{labelidx}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{labelidx}}_0~{{\mathit{labelidx}'}^\ast}` be :math:`{{\mathit{labelidx}''}^\ast}`. |
| |
| #. If :math:`{\mathit{labelidx}}_0 = 0`, then: |
| |
| a. Return :math:`{\mathrm{shift}}_{\mathit{labelidxs}}({{\mathit{labelidx}'}^\ast})`. |
| |
| #. Let :math:`{\mathit{labelidx}}~{{\mathit{labelidx}'}^\ast}` be :math:`{{\mathit{labelidx}''}^\ast}`. |
| |
| #. Return :math:`{\mathit{labelidx}} - 1~{\mathrm{shift}}_{\mathit{labelidxs}}({{\mathit{labelidx}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{instr}}({\mathit{instr}'})` |
| ........................................................... |
| |
| |
| 1. If :math:`{\mathit{instr}'} = \mathsf{nop}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{unreachable}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{drop}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{select}~{({{\mathit{valtype}}^\ast})^?}`, then: |
| |
| a. Let :math:`(\mathsf{select}~{({{\mathit{valtype}}^\ast})^?})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{opt}}({{\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{valtype}}({\mathit{valtype}})^\ast})^?})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{block}~{\mathit{blocktype}}~{{\mathit{instr}}^\ast}`, then: |
| |
| a. Let :math:`(\mathsf{block}~{\mathit{blocktype}}~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_blocktype(blocktype) ++ $free_block(instr*{instr <- instr*})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{loop}~{\mathit{blocktype}}~{{\mathit{instr}}^\ast}`, then: |
| |
| a. Let :math:`(\mathsf{loop}~{\mathit{blocktype}}~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_blocktype(blocktype) ++ $free_block(instr*{instr <- instr*})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{if}~{\mathit{blocktype}}~{{\mathit{instr}}^\ast}~\mathsf{else}~{{\mathit{instr}}^\ast}`, then: |
| |
| a. Let :math:`(\mathsf{if}~{\mathit{blocktype}}~{{\mathit{instr}}_1^\ast}~\mathsf{else}~{{\mathit{instr}}_2^\ast})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_blocktype(blocktype) ++ $free_block(instr_1*{instr_1 <- instr_1*}) ++ $free_block(instr_2*{instr_2 <- instr_2*})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{br}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{br}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{labelidx}}({\mathit{labelidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{br\_if}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{br\_if}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{labelidx}}({\mathit{labelidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{br\_table}~{{\mathit{labelidx}}^\ast}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{br\_table}~{{\mathit{labelidx}}^\ast}~{\mathit{labelidx}''})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_list($free_labelidx(labelidx)*{labelidx <- labelidx'*}) ++ $free_labelidx(labelidx'')`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{br\_on\_null}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{br\_on\_null}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{labelidx}}({\mathit{labelidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{br\_on\_non\_null}~{\mathit{labelidx}}`, then: |
| |
| a. Let :math:`(\mathsf{br\_on\_non\_null}~{\mathit{labelidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{labelidx}}({\mathit{labelidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{br\_on\_cast}~{\mathit{labelidx}}~{\mathit{reftype}}~{\mathit{reftype}}`, then: |
| |
| a. Let :math:`(\mathsf{br\_on\_cast}~{\mathit{labelidx}}~{\mathit{reftype}}_1~{\mathit{reftype}}_2)` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{br\_on\_cast\_fail}~{\mathit{labelidx}}~{\mathit{reftype}}~{\mathit{reftype}}`, then: |
| |
| a. Let :math:`(\mathsf{br\_on\_cast\_fail}~{\mathit{labelidx}}~{\mathit{reftype}}_1~{\mathit{reftype}}_2)` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{call}~{\mathit{funcidx}}`, then: |
| |
| a. Let :math:`(\mathsf{call}~{\mathit{funcidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{funcidx}}({\mathit{funcidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{call\_ref}~{\mathit{typeuse}}`, then: |
| |
| a. Let :math:`(\mathsf{call\_ref}~{\mathit{typeuse}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeuse}}({\mathit{typeuse}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{call\_indirect}~{\mathit{tableidx}}~{\mathit{typeuse}}`, then: |
| |
| a. Let :math:`(\mathsf{call\_indirect}~{\mathit{tableidx}}~{\mathit{typeuse}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_tableidx(tableidx) ++ $free_typeuse(typeuse)`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{return}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{return\_call}~{\mathit{funcidx}}`, then: |
| |
| a. Let :math:`(\mathsf{return\_call}~{\mathit{funcidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{funcidx}}({\mathit{funcidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{return\_call\_ref}~{\mathit{typeuse}}`, then: |
| |
| a. Let :math:`(\mathsf{return\_call\_ref}~{\mathit{typeuse}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeuse}}({\mathit{typeuse}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{return\_call\_indirect}~{\mathit{tableidx}}~{\mathit{typeuse}}`, then: |
| |
| a. Let :math:`(\mathsf{return\_call\_indirect}~{\mathit{tableidx}}~{\mathit{typeuse}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_tableidx(tableidx) ++ $free_typeuse(typeuse)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{throw}~{\mathit{tagidx}}`, then: |
| |
| a. Let :math:`(\mathsf{throw}~{\mathit{tagidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tagidx}}({\mathit{tagidx}})`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{throw\_ref}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{try\_table}~{\mathit{blocktype}}~{\mathit{list}}({\mathit{catch}})~{{\mathit{instr}}^\ast}`, then: |
| |
| a. Let :math:`(\mathsf{try\_table}~{\mathit{blocktype}}~{{\mathit{catch}}^\ast}~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_blocktype(blocktype) ++ $free_list($free_catch(catch)*{catch <- catch*}) ++ $free_list($free_instr(instr)*{instr <- instr*})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{numtype}}{.}\mathsf{const}~{{\mathit{num}}}_{{\mathit{numtype}}}`, then: |
| |
| a. Let :math:`({\mathit{numtype}}{.}\mathsf{const}~{\mathit{numlit}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{numtype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{numtype}} {.} {{\mathit{unop}}}_{{\mathit{numtype}}}`, then: |
| |
| a. Let :math:`({\mathit{numtype}} {.} {\mathit{unop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{numtype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{numtype}} {.} {{\mathit{binop}}}_{{\mathit{numtype}}}`, then: |
| |
| a. Let :math:`({\mathit{numtype}} {.} {\mathit{binop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{numtype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{numtype}} {.} {{\mathit{testop}}}_{{\mathit{numtype}}}`, then: |
| |
| a. Let :math:`({\mathit{numtype}} {.} {\mathit{testop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{numtype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{numtype}} {.} {{\mathit{relop}}}_{{\mathit{numtype}}}`, then: |
| |
| a. Let :math:`({\mathit{numtype}} {.} {\mathit{relop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{numtype}}({\mathit{numtype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{numtype}}_1 {.} {{{\mathit{cvtop}}}_{{\mathit{numtype}}_2, {\mathit{numtype}}_1}}{\mathsf{\_}}{{\mathit{numtype}}_2}`, then: |
| |
| a. Let :math:`({\mathit{numtype}}_1 {.} {{\mathit{cvtop}}}{\mathsf{\_}}{{\mathit{numtype}}_2})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_numtype(numtype_1) ++ $free_numtype(numtype_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{vectype}}{.}\mathsf{const}~{{\mathit{vec}}}_{{\mathit{vectype}}}`, then: |
| |
| a. Let :math:`({\mathit{vectype}}{.}\mathsf{const}~{\mathit{veclit}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{vectype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{vectype}} {.} {\mathit{vvunop}}`, then: |
| |
| a. Let :math:`({\mathit{vectype}} {.} {\mathit{vvunop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{vectype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{vectype}} {.} {\mathit{vvbinop}}`, then: |
| |
| a. Let :math:`({\mathit{vectype}} {.} {\mathit{vvbinop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{vectype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{vectype}} {.} {\mathit{vvternop}}`, then: |
| |
| a. Let :math:`({\mathit{vectype}} {.} {\mathit{vvternop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{vectype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{vectype}} {.} {\mathit{vvtestop}}`, then: |
| |
| a. Let :math:`({\mathit{vectype}} {.} {\mathit{vvtestop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{vectype}}({\mathit{vectype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}} {.} {{\mathit{vunop}}}_{{\mathit{shape}}}`, then: |
| |
| a. Let :math:`({\mathit{shape}} {.} {\mathit{vunop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}} {.} {{\mathit{vbinop}}}_{{\mathit{shape}}}`, then: |
| |
| a. Let :math:`({\mathit{shape}} {.} {\mathit{vbinop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}} {.} {{\mathit{vternop}}}_{{\mathit{shape}}}`, then: |
| |
| a. Let :math:`({\mathit{shape}} {.} {\mathit{vternop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}} {.} {{\mathit{vtestop}}}_{{\mathit{shape}}}`, then: |
| |
| a. Let :math:`({\mathit{shape}} {.} {\mathit{vtestop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}} {.} {{\mathit{vrelop}}}_{{\mathit{shape}}}`, then: |
| |
| a. Let :math:`({\mathit{shape}} {.} {\mathit{vrelop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{ishape}} {.} {{\mathit{vshiftop}}}_{{\mathit{ishape}}}`, then: |
| |
| a. Let :math:`({\mathit{ishape}} {.} {\mathit{vshiftop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{ishape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{ishape}}{.}\mathsf{bitmask}`, then: |
| |
| a. Let :math:`({\mathit{ishape}}{.}\mathsf{bitmask})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{ishape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{bshape}} {.} {{\mathit{vswizzlop}}}_{{\mathit{bshape}}}`, then: |
| |
| a. Let :math:`({\mathit{bshape}} {.} {\mathit{vswizzlop}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{bshape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{bshape}}{.}\mathsf{shuffle}~{{\mathit{laneidx}}^\ast}`, then: |
| |
| a. Let :math:`({\mathit{bshape}}{.}\mathsf{shuffle}~{{\mathit{laneidx}}^\ast})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{bshape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{ishape}}_1 {.} {{{\mathit{vextunop}}}_{{\mathit{ishape}}_2, {\mathit{ishape}}_1}}{\mathsf{\_}}{{\mathit{ishape}}_2}`, then: |
| |
| a. Let :math:`({\mathit{ishape}}_1 {.} {{\mathit{vextunop}}}{\mathsf{\_}}{{\mathit{ishape}}_2})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_shape(ishape_1) ++ $free_shape(ishape_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{ishape}}_1 {.} {{{\mathit{vextbinop}}}_{{\mathit{ishape}}_2, {\mathit{ishape}}_1}}{\mathsf{\_}}{{\mathit{ishape}}_2}`, then: |
| |
| a. Let :math:`({\mathit{ishape}}_1 {.} {{\mathit{vextbinop}}}{\mathsf{\_}}{{\mathit{ishape}}_2})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_shape(ishape_1) ++ $free_shape(ishape_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{ishape}}_1 {.} {{{\mathit{vextternop}}}_{{\mathit{ishape}}_2, {\mathit{ishape}}_1}}{\mathsf{\_}}{{\mathit{ishape}}_2}`, then: |
| |
| a. Let :math:`({\mathit{ishape}}_1 {.} {{\mathit{vextternop}}}{\mathsf{\_}}{{\mathit{ishape}}_2})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_shape(ishape_1) ++ $free_shape(ishape_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{{\mathit{ishape}}_1{.}\mathsf{narrow}}{\mathsf{\_}}{{\mathit{ishape}}_2}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| a. Let :math:`({{\mathit{ishape}}_1{.}\mathsf{narrow}}{\mathsf{\_}}{{\mathit{ishape}}_2}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_shape(ishape_1) ++ $free_shape(ishape_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}}_1 {.} {{{\mathit{vcvtop}}}_{{\mathit{shape}}_2, {\mathit{shape}}_1}}{\mathsf{\_}}{{\mathit{shape}}_2}`, then: |
| |
| a. Let :math:`({\mathit{shape}}_1 {.} {{\mathit{vcvtop}}}{\mathsf{\_}}{{\mathit{shape}}_2})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_shape(shape_1) ++ $free_shape(shape_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}}{.}\mathsf{splat}`, then: |
| |
| a. Let :math:`({\mathit{shape}}{.}\mathsf{splat})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{{\mathit{shape}}{.}\mathsf{extract\_lane}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~{\mathit{laneidx}}`, then: |
| |
| a. Let :math:`({{\mathit{shape}}{.}\mathsf{extract\_lane}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~{\mathit{laneidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{shape}}{.}\mathsf{replace\_lane}~{\mathit{laneidx}}`, then: |
| |
| a. Let :math:`({\mathit{shape}}{.}\mathsf{replace\_lane}~{\mathit{laneidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{shape}}({\mathit{shape}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{ref{.}null}~{\mathit{heaptype}}`, then: |
| |
| a. Let :math:`(\mathsf{ref{.}null}~{\mathit{heaptype}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{heaptype}}({\mathit{heaptype}})`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{ref{.}is\_null}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{ref{.}as\_non\_null}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{ref{.}eq}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{ref{.}test}~{\mathit{reftype}}`, then: |
| |
| a. Let :math:`(\mathsf{ref{.}test}~{\mathit{reftype}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{reftype}}({\mathit{reftype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{ref{.}cast}~{\mathit{reftype}}`, then: |
| |
| a. Let :math:`(\mathsf{ref{.}cast}~{\mathit{reftype}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{reftype}}({\mathit{reftype}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{ref{.}func}~{\mathit{funcidx}}`, then: |
| |
| a. Let :math:`(\mathsf{ref{.}func}~{\mathit{funcidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{funcidx}}({\mathit{funcidx}})`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{ref{.}i{\scriptstyle 31}}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathsf{i{\scriptstyle 31}{.}get}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{struct{.}new}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`(\mathsf{struct{.}new}~{\mathit{typeidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{struct{.}new\_default}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`(\mathsf{struct{.}new\_default}~{\mathit{typeidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathsf{struct{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~{\mathit{typeidx}}~{\mathit{fieldidx}}`, then: |
| |
| a. Let :math:`({\mathsf{struct{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~{\mathit{typeidx}}~{\mathit{u{\kern-0.1em\scriptstyle 32}}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{struct{.}set}~{\mathit{typeidx}}~{\mathit{fieldidx}}`, then: |
| |
| a. Let :math:`(\mathsf{struct{.}set}~{\mathit{typeidx}}~{\mathit{u{\kern-0.1em\scriptstyle 32}}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}new}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}new}~{\mathit{typeidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}new\_default}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}new\_default}~{\mathit{typeidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}new\_fixed}~{\mathit{typeidx}}~{\mathit{u{\kern-0.1em\scriptstyle 32}}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}new\_fixed}~{\mathit{typeidx}}~{\mathit{u{\kern-0.1em\scriptstyle 32}}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}new\_data}~{\mathit{typeidx}}~{\mathit{dataidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}new\_data}~{\mathit{typeidx}}~{\mathit{dataidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_typeidx(typeidx) ++ $free_dataidx(dataidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}new\_elem}~{\mathit{typeidx}}~{\mathit{elemidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}new\_elem}~{\mathit{typeidx}}~{\mathit{elemidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_typeidx(typeidx) ++ $free_elemidx(elemidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`({\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~{\mathit{typeidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}set}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}set}~{\mathit{typeidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{array{.}len}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}fill}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}fill}~{\mathit{typeidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}copy}~{\mathit{typeidx}}~{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}copy}~{\mathit{typeidx}}_1~{\mathit{typeidx}}_2)` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_typeidx(typeidx_1) ++ $free_typeidx(typeidx_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}init\_data}~{\mathit{typeidx}}~{\mathit{dataidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}init\_data}~{\mathit{typeidx}}~{\mathit{dataidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_typeidx(typeidx) ++ $free_dataidx(dataidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{array{.}init\_elem}~{\mathit{typeidx}}~{\mathit{elemidx}}`, then: |
| |
| a. Let :math:`(\mathsf{array{.}init\_elem}~{\mathit{typeidx}}~{\mathit{elemidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_typeidx(typeidx) ++ $free_elemidx(elemidx)`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{extern{.}convert\_any}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'} = \mathsf{any{.}convert\_extern}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{local{.}get}~{\mathit{localidx}}`, then: |
| |
| a. Let :math:`(\mathsf{local{.}get}~{\mathit{localidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{localidx}}({\mathit{localidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{local{.}set}~{\mathit{localidx}}`, then: |
| |
| a. Let :math:`(\mathsf{local{.}set}~{\mathit{localidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{localidx}}({\mathit{localidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{local{.}tee}~{\mathit{localidx}}`, then: |
| |
| a. Let :math:`(\mathsf{local{.}tee}~{\mathit{localidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{localidx}}({\mathit{localidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{global{.}get}~{\mathit{globalidx}}`, then: |
| |
| a. Let :math:`(\mathsf{global{.}get}~{\mathit{globalidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{globalidx}}({\mathit{globalidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{global{.}set}~{\mathit{globalidx}}`, then: |
| |
| a. Let :math:`(\mathsf{global{.}set}~{\mathit{globalidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{globalidx}}({\mathit{globalidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{table{.}get}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table{.}get}~{\mathit{tableidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{table{.}set}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table{.}set}~{\mathit{tableidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{table{.}size}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table{.}size}~{\mathit{tableidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{table{.}grow}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table{.}grow}~{\mathit{tableidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{table{.}fill}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table{.}fill}~{\mathit{tableidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{table{.}copy}~{\mathit{tableidx}}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table{.}copy}~{\mathit{tableidx}}_1~{\mathit{tableidx}}_2)` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_tableidx(tableidx_1) ++ $free_tableidx(tableidx_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{table{.}init}~{\mathit{tableidx}}~{\mathit{elemidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table{.}init}~{\mathit{tableidx}}~{\mathit{elemidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_tableidx(tableidx) ++ $free_elemidx(elemidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{elem{.}drop}~{\mathit{elemidx}}`, then: |
| |
| a. Let :math:`(\mathsf{elem{.}drop}~{\mathit{elemidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{elemidx}}({\mathit{elemidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{{\mathit{numtype}}{.}\mathsf{load}}{{{{\mathit{loadop}}}_{{\mathit{numtype}}}^?}}~{\mathit{memidx}}~{\mathit{memarg}}`, then: |
| |
| a. Let :math:`({{\mathit{numtype}}{.}\mathsf{load}}{{{\mathit{loadop}}^?}}~{\mathit{memidx}}~{\mathit{memarg}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_numtype(numtype) ++ $free_memidx(memidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{{\mathit{numtype}}{.}\mathsf{store}}{{{{\mathit{storeop}}}_{{\mathit{numtype}}}^?}}~{\mathit{memidx}}~{\mathit{memarg}}`, then: |
| |
| a. Let :math:`({{\mathit{numtype}}{.}\mathsf{store}}{{{\mathit{storeop}}^?}}~{\mathit{memidx}}~{\mathit{memarg}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_numtype(numtype) ++ $free_memidx(memidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{{\mathit{vectype}}{.}\mathsf{load}}{{{{\mathit{vloadop}}}_{{\mathit{vectype}}}^?}}~{\mathit{memidx}}~{\mathit{memarg}}`, then: |
| |
| a. Let :math:`({{\mathit{vectype}}{.}\mathsf{load}}{{{\mathit{vloadop}}^?}}~{\mathit{memidx}}~{\mathit{memarg}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_vectype(vectype) ++ $free_memidx(memidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{{\mathit{vectype}}{.}\mathsf{load}}{{\mathit{sz}}}{\mathsf{\_}}{\mathsf{lane}}~{\mathit{memidx}}~{\mathit{memarg}}~{\mathit{laneidx}}`, then: |
| |
| a. Let :math:`({{\mathit{vectype}}{.}\mathsf{load}}{{\mathit{sz}}}{\mathsf{\_}}{\mathsf{lane}}~{\mathit{memidx}}~{\mathit{memarg}}~{\mathit{laneidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_vectype(vectype) ++ $free_memidx(memidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{\mathit{vectype}}{.}\mathsf{store}~{\mathit{memidx}}~{\mathit{memarg}}`, then: |
| |
| a. Let :math:`({\mathit{vectype}}{.}\mathsf{store}~{\mathit{memidx}}~{\mathit{memarg}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_vectype(vectype) ++ $free_memidx(memidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`{{\mathit{vectype}}{.}\mathsf{store}}{{\mathit{sz}}}{\mathsf{\_}}{\mathsf{lane}}~{\mathit{memidx}}~{\mathit{memarg}}~{\mathit{laneidx}}`, then: |
| |
| a. Let :math:`({{\mathit{vectype}}{.}\mathsf{store}}{{\mathit{sz}}}{\mathsf{\_}}{\mathsf{lane}}~{\mathit{memidx}}~{\mathit{memarg}}~{\mathit{laneidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_vectype(vectype) ++ $free_memidx(memidx)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{memory{.}size}~{\mathit{memidx}}`, then: |
| |
| a. Let :math:`(\mathsf{memory{.}size}~{\mathit{memidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{memidx}}({\mathit{memidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{memory{.}grow}~{\mathit{memidx}}`, then: |
| |
| a. Let :math:`(\mathsf{memory{.}grow}~{\mathit{memidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{memidx}}({\mathit{memidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{memory{.}fill}~{\mathit{memidx}}`, then: |
| |
| a. Let :math:`(\mathsf{memory{.}fill}~{\mathit{memidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{memidx}}({\mathit{memidx}})`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{memory{.}copy}~{\mathit{memidx}}~{\mathit{memidx}}`, then: |
| |
| a. Let :math:`(\mathsf{memory{.}copy}~{\mathit{memidx}}_1~{\mathit{memidx}}_2)` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_memidx(memidx_1) ++ $free_memidx(memidx_2)`. |
| |
| #. If :math:`{\mathit{instr}'}` is some :math:`\mathsf{memory{.}init}~{\mathit{memidx}}~{\mathit{dataidx}}`, then: |
| |
| a. Let :math:`(\mathsf{memory{.}init}~{\mathit{memidx}}~{\mathit{dataidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return `$free_memidx(memidx) ++ $free_dataidx(dataidx)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{instr}'}` is some :math:`\mathsf{data{.}drop}~{\mathit{dataidx}}`. |
| |
| #. Let :math:`(\mathsf{data{.}drop}~{\mathit{dataidx}})` be the destructuring of :math:`{\mathit{instr}'}`. |
| |
| #. Return :math:`{\mathrm{free}}_{\mathit{dataidx}}({\mathit{dataidx}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{block}}({{\mathit{instr}}^\ast})` |
| ................................................................. |
| |
| |
| 1. Let :math:`{\mathit{free}}` be :math:`{\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{instr}}({\mathit{instr}})^\ast})`. |
| |
| #. Return :math:`{\mathit{free}}{}[{.}\mathsf{labels} = {\mathrm{shift}}_{\mathit{labelidxs}}({\mathit{free}}{.}\mathsf{labels})]`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{expr}}({{\mathit{instr}}^\ast})` |
| ................................................................ |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{instr}}({\mathit{instr}})^\ast})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{type}}(\mathsf{type}~{\mathit{rectype}})` |
| ......................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{rectype}}({\mathit{rectype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{tag}}(\mathsf{tag}~{\mathit{tagtype}})` |
| ....................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{tagtype}}({\mathit{tagtype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{global}}(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}})` |
| ................................................................................................ |
| |
| |
| 1. Return `$free_globaltype(globaltype) ++ $free_expr(expr)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{mem}}(\mathsf{memory}~{\mathit{memtype}})` |
| .......................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{memtype}}({\mathit{memtype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{table}}(\mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}})` |
| ............................................................................................. |
| |
| |
| 1. Return `$free_tabletype(tabletype) ++ $free_expr(expr)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{local}}(\mathsf{local}~t)` |
| .......................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{valtype}}(t)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{func}}(\mathsf{func}~{\mathit{typeidx}}~{{\mathit{local}}^\ast}~{\mathit{expr}})` |
| ................................................................................................................. |
| |
| |
| 1. Return `$free_typeidx(typeidx) ++ $free_list($free_local(local)*{local <- local*}) ++ update($free_block(expr).LOCALS, [])`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{datamode}}({\mathit{datamode}})` |
| ................................................................ |
| |
| |
| 1. If :math:`{\mathit{datamode}}` is some :math:`\mathsf{active}~{\mathit{memidx}}~{\mathit{expr}}`, then: |
| |
| a. Let :math:`(\mathsf{active}~{\mathit{memidx}}~{\mathit{expr}})` be the destructuring of :math:`{\mathit{datamode}}`. |
| |
| #. Return `$free_memidx(memidx) ++ $free_expr(expr)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{datamode}} = \mathsf{passive}`. |
| |
| #. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{data}}(\mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}})` |
| ................................................................................................. |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{datamode}}({\mathit{datamode}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{elemmode}}({\mathit{elemmode}})` |
| ................................................................ |
| |
| |
| 1. If :math:`{\mathit{elemmode}}` is some :math:`\mathsf{active}~{\mathit{tableidx}}~{\mathit{expr}}`, then: |
| |
| a. Let :math:`(\mathsf{active}~{\mathit{tableidx}}~{\mathit{expr}})` be the destructuring of :math:`{\mathit{elemmode}}`. |
| |
| #. Return `$free_tableidx(tableidx) ++ $free_expr(expr)`. |
| |
| #. If :math:`{\mathit{elemmode}} = \mathsf{passive}`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{elemmode}} = \mathsf{declare}`. |
| |
| #. Return :math:`\{ \}`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{elem}}(\mathsf{elem}~{\mathit{reftype}}~{{\mathit{expr}}^\ast}~{\mathit{elemmode}})` |
| .................................................................................................................... |
| |
| |
| 1. Return `$free_reftype(reftype) ++ $free_list($free_expr(expr)*{expr <- expr*}) ++ $free_elemmode(elemmode)`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{start}}(\mathsf{start}~{\mathit{funcidx}})` |
| ........................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{funcidx}}({\mathit{funcidx}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{import}}(\mathsf{import}~{\mathit{name}}_1~{\mathit{name}}_2~{\mathit{externtype}})` |
| .................................................................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{externtype}}({\mathit{externtype}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{export}}(\mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` |
| ............................................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{externidx}}({\mathit{externidx}})`. |
| |
| |
| :math:`{\mathrm{free}}_{\mathit{module}}(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` |
| .......................................................................................................................................................................................................................................................................................................................... |
| |
| |
| 1. Return `$free_list($free_type(type)*{type <- type*}) ++ $free_list($free_tag(tag)*{tag <- tag*}) ++ $free_list($free_global(global)*{global <- global*}) ++ $free_list($free_mem(mem)*{mem <- mem*}) ++ $free_list($free_table(table)*{table <- table*}) ++ $free_list($free_func(func)*{func <- func*}) ++ $free_list($free_data(data)*{data <- data*}) ++ $free_list($free_elem(elem)*{elem <- elem*}) ++ $free_opt($free_start(start)?{start <- start?}) ++ $free_list($free_import(import)*{import <- import*}) ++ $free_list($free_export(export)*{export <- export*})`. |
| |
| |
| :math:`{\mathrm{funcidx}}({\mathit{module}})` |
| ............................................. |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{module}}({\mathit{module}}){.}\mathsf{funcs}`. |
| |
| |
| :math:`{\mathrm{dataidx}}({{\mathit{func}}^\ast})` |
| .................................................. |
| |
| |
| 1. Return :math:`{\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{func}}({\mathit{func}})^\ast}){.}\mathsf{datas}`. |
| |
| |
| :math:`C` with the local types of :math:`{{\mathit{localidx}}^\ast}` updated to :math:`{{\mathit{localtype}}^\ast}` |
| ................................................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{localtype}}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{\mathit{localidx}}^\ast} = \epsilon`. |
| |
| #. Return :math:`C`. |
| |
| #. Else: |
| |
| a. Let :math:`{{\mathit{lt}}}_1~{{{\mathit{lt}}}^\ast}` be :math:`{{\mathit{localtype}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{localidx}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`x_1~{x^\ast}` be :math:`{{\mathit{localidx}}^\ast}`. |
| |
| #. Return :math:`C{}[{.}\mathsf{locals}{}[x_1] = {{\mathit{lt}}}_1]` with the local types of :math:`{x^\ast}` updated to :math:`{{{\mathit{lt}}}^\ast}`. |
| |
| |
| :math:`{{{\mathrm{clos}}^\ast}}{({{\mathit{deftype}}^\ast})}` |
| ............................................................. |
| |
| |
| 1. If :math:`{{\mathit{deftype}}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{{\mathit{dt}}^\ast}~{\mathit{dt}}_n` be :math:`{{\mathit{deftype}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{dt}'}^\ast}` be :math:`{{{\mathrm{clos}}^\ast}}{({{\mathit{dt}}^\ast})}`. |
| |
| #. Return :math:`{{\mathit{dt}'}^\ast}~{{\mathit{dt}}_n}{{}[ {:=}\, {{\mathit{dt}'}^\ast} ]}`. |
| |
| |
| :math:`{{\mathrm{clos}}}_{C}(t)` |
| ................................ |
| |
| |
| 1. Let :math:`{{\mathit{dt}}^\ast}` be :math:`{{{\mathrm{clos}}^\ast}}{(C{.}\mathsf{types})}`. |
| |
| #. Return :math:`{t}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]}`. |
| |
| |
| :math:`{{\mathrm{clos}}}_{C}({\mathit{dt}})` |
| ............................................ |
| |
| |
| 1. Let :math:`{{\mathit{dt}'}^\ast}` be :math:`{{{\mathrm{clos}}^\ast}}{(C{.}\mathsf{types})}`. |
| |
| #. Return :math:`{{\mathit{dt}}}{{}[ {:=}\, {{\mathit{dt}'}^\ast} ]}`. |
| |
| |
| :math:`{{\mathrm{clos}}}_{C}({\mathit{jt}})` |
| ............................................ |
| |
| |
| 1. Let :math:`{{\mathit{dt}}^\ast}` be :math:`{{{\mathrm{clos}}^\ast}}{(C{.}\mathsf{types})}`. |
| |
| #. Return :math:`{{\mathit{jt}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]}`. |
| |
| |
| :math:`{{\mathrm{clos}}}_{C}({\mathit{xt}})` |
| ............................................ |
| |
| |
| 1. Let :math:`{{\mathit{dt}}^\ast}` be :math:`{{{\mathrm{clos}}^\ast}}{(C{.}\mathsf{types})}`. |
| |
| #. Return :math:`{{\mathit{xt}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]}`. |
| |
| |
| :math:`{{\mathrm{clos}}}_{C}({\mathit{mmt}})` |
| ............................................. |
| |
| |
| 1. Let :math:`{{\mathit{dt}}^\ast}` be :math:`{{{\mathrm{clos}}^\ast}}{(C{.}\mathsf{types})}`. |
| |
| #. Return :math:`{{\mathit{mmt}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]}`. |
| |
| |
| :math:`{\mathit{typeuse}} \prec i` |
| .................................. |
| |
| |
| 1. If :math:`{\mathit{typeuse}}` is not some :math:`\mathsf{rec} {.} n`, then: |
| |
| a. Return true. |
| |
| #. Let :math:`(\mathsf{rec} {.} j)` be the destructuring of :math:`{\mathit{typeuse}}`. |
| |
| #. Return :math:`j < i`. |
| |
| |
| :math:`{{\mathrm{unrollht}}}_{C}({\mathit{heaptype}})` |
| ...................................................... |
| |
| |
| 1. If :math:`{\mathit{heaptype}}` is defined type, then: |
| |
| a. Return :math:`{\mathrm{unroll}}({\mathit{heaptype}})`. |
| |
| #. If :math:`{\mathit{heaptype}}` is some :math:`{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`{\mathit{typeidx}}` be the heap type :math:`{\mathit{heaptype}}`. |
| |
| #. Return :math:`{\mathrm{unroll}}(C{.}\mathsf{types}{}[{\mathit{typeidx}}])`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{heaptype}}` is some :math:`\mathsf{rec} {.} n`. |
| |
| #. Let :math:`(\mathsf{rec} {.} i)` be the destructuring of :math:`{\mathit{heaptype}}`. |
| |
| #. Return :math:`C{.}\mathsf{recs}{}[i]`. |
| |
| |
| :math:`{{\mathrm{default}}}_{{\mathit{valtype}}}` |
| ................................................. |
| |
| |
| 1. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. Return :math:`({\mathit{valtype}}{.}\mathsf{const}~0)`. |
| |
| #. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{f}}{N}`, then: |
| |
| a. Return :math:`({\mathit{valtype}}{.}\mathsf{const}~{+0})`. |
| |
| #. If :math:`{\mathit{valtype}}` is :math:`{\mathsf{v}}{N}`, then: |
| |
| a. Return :math:`({\mathit{valtype}}{.}\mathsf{const}~0)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{valtype}}` is some :math:`\mathsf{ref}~{\mathsf{null}^?}~{\mathit{heaptype}}`. |
| |
| #. Let :math:`(\mathsf{ref}~{{\mathit{NULL}}_0^?}~{\mathit{ht}})` be the destructuring of :math:`{\mathit{valtype}}`. |
| |
| #. If :math:`{{\mathit{NULL}}_0^?} = \mathsf{null}`, then: |
| |
| a. Return :math:`\mathsf{ref{.}null}`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{NULL}}_0^?}` is not defined. |
| |
| #. Return :math:`\epsilon`. |
| |
| |
| :math:`{\mathit{zt}}` is a packed type |
| ...................................... |
| |
| |
| 1. Return :math:`{\mathit{zt}} \neq {\mathrm{unpack}}({\mathit{zt}})`. |
| |
| |
| :math:`{\mathrm{funcidx}}({{\mathit{global}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` |
| ....................................................................................................................................................................... |
| |
| |
| 1. Return :math:`{\mathrm{funcidx}}(\mathsf{module}~{{\mathit{global}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})`. |
| |
| |
| :math:`{{\mathrm{relaxed}}(i)}{{}[ X_1, X_2 ]}` |
| ............................................... |
| |
| |
| 1. If :math:`{\mathrm{ND}}`, then: |
| |
| a. Return :math:`X_1~X_2{}[i]`. |
| |
| #. Return :math:`X_1~X_2{}[0]`. |
| |
| |
| :math:`{{\mathrm{relaxed}}(i)}{{}[ X_1, X_2, X_3, X_4 ]}` |
| ......................................................... |
| |
| |
| 1. If :math:`{\mathrm{ND}}`, then: |
| |
| a. Return :math:`X_1~X_2~X_3~X_4{}[i]`. |
| |
| #. Return :math:`X_1~X_2~X_3~X_4{}[0]`. |
| |
| |
| :math:`{{\mathrm{signed}}}_{N}(i)` |
| .................................. |
| |
| |
| 1. If :math:`i < {2^{N - 1}}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{2^{N - 1}} \leq i`. |
| |
| #. Assert: Due to validation, :math:`i < {2^{N}}`. |
| |
| #. Return :math:`i - {2^{N}}`. |
| |
| |
| :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{(i)}` |
| ............................................... |
| |
| |
| 1. If :math:`0 \leq i` and :math:`i < {2^{N - 1}}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{-{2^{N - 1}}} \leq i`. |
| |
| #. Assert: Due to validation, :math:`i < 0`. |
| |
| #. Return :math:`i + {2^{N}}`. |
| |
| |
| :math:`{\mathrm{sx}}({\mathit{storagetype}})` |
| ............................................. |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is constant type, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Return :math:`\mathsf{s}`. |
| |
| |
| :math:`0` |
| ......... |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. Return :math:`0`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. Return :math:`{+0}`. |
| |
| |
| :math:`\mathbb{B}(b)` |
| ..................... |
| |
| |
| 1. If :math:`b` is false, then: |
| |
| a. Return :math:`0`. |
| |
| #. Assert: Due to validation, :math:`b` is true. |
| |
| #. Return :math:`1`. |
| |
| |
| :math:`{{\mathrm{sat\_u}}}_{N}(i)` |
| .................................. |
| |
| |
| 1. If :math:`i < 0`, then: |
| |
| a. Return :math:`0`. |
| |
| #. If :math:`i > {2^{N}} - 1`, then: |
| |
| a. Return :math:`{2^{N}} - 1`. |
| |
| #. Return :math:`i`. |
| |
| |
| :math:`{{\mathrm{sat\_s}}}_{N}(i)` |
| .................................. |
| |
| |
| 1. If :math:`i < {-{2^{N - 1}}}`, then: |
| |
| a. Return :math:`{-{2^{N - 1}}}`. |
| |
| #. If :math:`i > {2^{N - 1}} - 1`, then: |
| |
| a. Return :math:`{2^{N - 1}} - 1`. |
| |
| #. Return :math:`i`. |
| |
| |
| :math:`{{\mathrm{ineg}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`({2^{N}} - i_1) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{\mathrm{iabs}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. If :math:`{{\mathrm{signed}}}_{N}(i_1) \geq 0`, then: |
| |
| a. Return :math:`i_1`. |
| |
| #. Return :math:`{{\mathrm{ineg}}}_{N}(i_1)`. |
| |
| |
| :math:`{{{{\mathrm{iextend}}}_{N, K}^{{\mathit{sx}}}}}{(i)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`i \mathbin{\mathrm{mod}} ({2^{K}})`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({{\mathrm{signed}}}_{K}(i \mathbin{\mathrm{mod}} ({2^{K}})))}`. |
| |
| |
| :math:`{{\mathrm{iadd}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`(i_1 + i_2) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{\mathrm{isub}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`({2^{N}} + i_1 - i_2) \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{\mathrm{imul}}}_{N}(i_1, i_2)` |
| ....................................... |
| |
| |
| 1. Return :math:`i_1 \cdot i_2 \mathbin{\mathrm{mod}} ({2^{N}})`. |
| |
| |
| :math:`{{\mathrm{idiv}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| .......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_2 = 0`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Return :math:`{\mathrm{truncz}}(i_1 / i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`i_2 = 0`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i_1) / {{\mathrm{signed}}}_{N}(i_2) = {2^{N - 1}}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({\mathrm{truncz}}({{\mathrm{signed}}}_{N}(i_1) / {{\mathrm{signed}}}_{N}(i_2)))}`. |
| |
| |
| :math:`{{\mathrm{irem}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| .......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_2 = 0`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Return :math:`i_1 - i_2 \cdot {\mathrm{truncz}}(i_1 / i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`i_2 = 0`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`j_1` be :math:`{{\mathrm{signed}}}_{N}(i_1)`. |
| |
| #. Let :math:`j_2` be :math:`{{\mathrm{signed}}}_{N}(i_2)`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{(j_1 - j_2 \cdot {\mathrm{truncz}}(j_1 / j_2))}`. |
| |
| |
| :math:`{{\mathrm{imin}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| .......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_1 \leq i_2`, then: |
| |
| 1) Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i_1) \leq {{\mathrm{signed}}}_{N}(i_2)`, then: |
| |
| a. Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| |
| :math:`{{\mathrm{imax}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| .......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. If :math:`i_1 \geq i_2`, then: |
| |
| 1) Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i_1) \geq {{\mathrm{signed}}}_{N}(i_2)`, then: |
| |
| a. Return :math:`i_1`. |
| |
| #. Return :math:`i_2`. |
| |
| |
| :math:`{{\mathrm{iadd\_sat}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| ............................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`{{\mathrm{sat\_u}}}_{N}(i_1 + i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({{\mathrm{sat\_s}}}_{N}({{\mathrm{signed}}}_{N}(i_1) + {{\mathrm{signed}}}_{N}(i_2)))}`. |
| |
| |
| :math:`{{\mathrm{isub\_sat}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| ............................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`{{\mathrm{sat\_u}}}_{N}(i_1 - i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`{{{{\mathrm{signed}}}_{N}^{{-1}}}}{({{\mathrm{sat\_s}}}_{N}({{\mathrm{signed}}}_{N}(i_1) - {{\mathrm{signed}}}_{N}(i_2)))}`. |
| |
| |
| :math:`{{\mathrm{ieqz}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 = 0)`. |
| |
| |
| :math:`{{\mathrm{inez}}}_{N}(i_1)` |
| .................................. |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 \neq 0)`. |
| |
| |
| :math:`{{\mathrm{ieq}}}_{N}(i_1, i_2)` |
| ...................................... |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 = i_2)`. |
| |
| |
| :math:`{{\mathrm{ine}}}_{N}(i_1, i_2)` |
| ...................................... |
| |
| |
| 1. Return :math:`\mathbb{B}(i_1 \neq i_2)`. |
| |
| |
| :math:`{{\mathrm{ilt}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| ......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 < i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) < {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{\mathrm{igt}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| ......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 > i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) > {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{\mathrm{ile}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| ......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 \leq i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) \leq {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{\mathrm{ige}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}` |
| ......................................................... |
| |
| |
| 1. If :math:`{\mathit{sx}} = \mathsf{u}`, then: |
| |
| a. Return :math:`\mathbb{B}(i_1 \geq i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{sx}} = \mathsf{s}`. |
| |
| #. Return :math:`\mathbb{B}({{\mathrm{signed}}}_{N}(i_1) \geq {{\mathrm{signed}}}_{N}(i_2))`. |
| |
| |
| :math:`{{\mathrm{pack}}}_{{\mathit{lanetype}}}(c)` |
| .................................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`{{\mathrm{wrap}}}_{{|{\mathrm{unpack}}({\mathit{lanetype}})|}, {|{\mathit{lanetype}}|}}(c)`. |
| |
| |
| :math:`{{\mathrm{pack}}}_{{\mathit{storagetype}}}(c)` |
| ..................................................... |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is constant type, then: |
| |
| a. Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Return :math:`{{\mathrm{wrap}}}_{{|{\mathrm{unpack}}({\mathit{storagetype}})|}, {|{\mathit{storagetype}}|}}(c)`. |
| |
| |
| :math:`{{\mathrm{unpack}}}_{{\mathit{lanetype}}}(c)` |
| .................................................... |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is number type, then: |
| |
| a. Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is packed type. |
| |
| #. Return :math:`{{{{\mathrm{extend}}}_{{|{\mathit{lanetype}}|}, {|{\mathrm{unpack}}({\mathit{lanetype}})|}}^{\mathsf{u}}}}{(c)}`. |
| |
| |
| :math:`{{\mathrm{unpack}}}_{{\mathit{storagetype}}}(c)` |
| ....................................................... |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is constant type, then: |
| |
| a. Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Return :math:`{{{{\mathrm{extend}}}_{{|{\mathit{storagetype}}|}, {|{\mathrm{unpack}}({\mathit{storagetype}})|}}^{\mathsf{u}}}}{(c)}`. |
| |
| |
| :math:`{{\mathit{unop}}}{{}_{{\mathit{numtype}}}(i)}` |
| ..................................................... |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{unop}} = \mathsf{clz}`, then: |
| |
| 1) Return :math:`{{\mathrm{iclz}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{ctz}`, then: |
| |
| 1) Return :math:`{{\mathrm{ictz}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{popcnt}`, then: |
| |
| 1) Return :math:`{{\mathrm{ipopcnt}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}}` is some :math:`{\mathsf{extend}}{{\mathit{sz}}}{\mathsf{\_}}{\mathsf{s}}`, then: |
| |
| 1) Let :math:`({\mathsf{extend}}{N}{\mathsf{\_}}{\mathsf{s}})` be the destructuring of :math:`{\mathit{unop}}`. |
| |
| #) Return :math:`{{{{\mathrm{iextend}}}_{N, N}^{\mathsf{s}}}}{(i)}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{abs}`, then: |
| |
| a. Return :math:`{{\mathrm{fabs}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{neg}`, then: |
| |
| a. Return :math:`{{\mathrm{fneg}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{sqrt}`, then: |
| |
| a. Return :math:`{{\mathrm{fsqrt}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{ceil}`, then: |
| |
| a. Return :math:`{{\mathrm{fceil}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{floor}`, then: |
| |
| a. Return :math:`{{\mathrm{ffloor}}}_{N}(i)`. |
| |
| #. If :math:`{\mathit{unop}} = \mathsf{trunc}`, then: |
| |
| a. Return :math:`{{\mathrm{ftrunc}}}_{N}(i)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{unop}} = \mathsf{nearest}`. |
| |
| #. Return :math:`{{\mathrm{fnearest}}}_{N}(i)`. |
| |
| |
| :math:`{{\mathit{binop}}}{{}_{{\mathit{numtype}}}(i_1, i_2)}` |
| ............................................................. |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{binop}} = \mathsf{add}`, then: |
| |
| 1) Return :math:`{{\mathrm{iadd}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{sub}`, then: |
| |
| 1) Return :math:`{{\mathrm{isub}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{mul}`, then: |
| |
| 1) Return :math:`{{\mathrm{imul}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{div}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{div}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{\mathrm{idiv}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{rem}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{rem}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{\mathrm{irem}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{and}`, then: |
| |
| 1) Return :math:`{{\mathrm{iand}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{or}`, then: |
| |
| 1) Return :math:`{{\mathrm{ior}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{xor}`, then: |
| |
| 1) Return :math:`{{\mathrm{ixor}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{shl}`, then: |
| |
| 1) Return :math:`{{\mathrm{ishl}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}}` is some :math:`{\mathsf{shr}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{shr}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{binop}}`. |
| |
| #) Return :math:`{{\mathrm{ishr}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{rotl}`, then: |
| |
| 1) Return :math:`{{\mathrm{irotl}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{rotr}`, then: |
| |
| 1) Return :math:`{{\mathrm{irotr}}}_{N}(i_1, i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{add}`, then: |
| |
| a. Return :math:`{{\mathrm{fadd}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{sub}`, then: |
| |
| a. Return :math:`{{\mathrm{fsub}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{mul}`, then: |
| |
| a. Return :math:`{{\mathrm{fmul}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{div}`, then: |
| |
| a. Return :math:`{{\mathrm{fdiv}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{min}`, then: |
| |
| a. Return :math:`{{\mathrm{fmin}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{binop}} = \mathsf{max}`, then: |
| |
| a. Return :math:`{{\mathrm{fmax}}}_{N}(i_1, i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{binop}} = \mathsf{copysign}`. |
| |
| #. Return :math:`{{\mathrm{fcopysign}}}_{N}(i_1, i_2)`. |
| |
| |
| :math:`{\mathsf{eqz}}{{}_{{\mathsf{i}}{N}}(i)}` |
| ............................................... |
| |
| |
| 1. Return :math:`{{\mathrm{ieqz}}}_{N}(i)`. |
| |
| |
| :math:`{{\mathit{relop}}}{{}_{{\mathit{numtype}}}(i_1, i_2)}` |
| ............................................................. |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{relop}} = \mathsf{eq}`, then: |
| |
| 1) Return :math:`{{\mathrm{ieq}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{ne}`, then: |
| |
| 1) Return :math:`{{\mathrm{ine}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{lt}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{lt}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{\mathrm{ilt}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{gt}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{gt}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{\mathrm{igt}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{le}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{le}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{\mathrm{ile}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}`. |
| |
| #. If :math:`{\mathit{relop}}` is some :math:`{\mathsf{ge}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{ge}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{relop}}`. |
| |
| #) Return :math:`{{\mathrm{ige}}}{{\mathit{sx}}}{{}_{N}(i_1, i_2)}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{eq}`, then: |
| |
| a. Return :math:`{{\mathrm{feq}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{ne}`, then: |
| |
| a. Return :math:`{{\mathrm{fne}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{lt}`, then: |
| |
| a. Return :math:`{{\mathrm{flt}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{gt}`, then: |
| |
| a. Return :math:`{{\mathrm{fgt}}}_{N}(i_1, i_2)`. |
| |
| #. If :math:`{\mathit{relop}} = \mathsf{le}`, then: |
| |
| a. Return :math:`{{\mathrm{fle}}}_{N}(i_1, i_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{relop}} = \mathsf{ge}`. |
| |
| #. Return :math:`{{\mathrm{fge}}}_{N}(i_1, i_2)`. |
| |
| |
| :math:`{{\mathit{cvtop}}}{{}_{{\mathit{numtype}}, {\mathit{numtype}'}}(i_1)}` |
| ............................................................................. |
| |
| |
| 1. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{N}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{cvtop}}` is some :math:`{\mathsf{extend}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{extend}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #) Return :math:`{{{{\mathrm{extend}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(i_1)}`. |
| |
| #. If :math:`{\mathit{cvtop}} = \mathsf{wrap}`, then: |
| |
| 1) Return :math:`{{\mathrm{wrap}}}_{N_1, N_2}(i_1)`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{N}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{cvtop}}` is some :math:`{\mathsf{trunc}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{trunc}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #) Return :math:`{{{{\mathrm{trunc}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(i_1)}`. |
| |
| #. If :math:`{\mathit{cvtop}}` is some :math:`{\mathsf{trunc\_sat}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{trunc\_sat}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #) Return :math:`{{{{\mathrm{trunc\_sat}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(i_1)}`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{N}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{f}}{N}` and :math:`{\mathit{cvtop}}` is some :math:`{\mathsf{convert}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| a. Let :math:`({\mathsf{convert}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{cvtop}}`. |
| |
| #. Return :math:`{{{{\mathrm{convert}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(i_1)}`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{N}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{f}}{N}`, then: |
| |
| a. If :math:`{\mathit{cvtop}} = \mathsf{promote}`, then: |
| |
| 1) Return :math:`{{\mathrm{promote}}}_{N_1, N_2}(i_1)`. |
| |
| #. If :math:`{\mathit{cvtop}} = \mathsf{demote}`, then: |
| |
| 1) Return :math:`{{\mathrm{demote}}}_{N_1, N_2}(i_1)`. |
| |
| #. If :math:`{\mathit{numtype}}` is :math:`{\mathsf{i}}{N}` and :math:`{\mathit{numtype}'}` is :math:`{\mathsf{f}}{N}` and :math:`{\mathit{cvtop}} = \mathsf{reinterpret}` and :math:`{|{\mathit{numtype}}|} = {|{\mathit{numtype}'}|}`, then: |
| |
| a. Return :math:`{{\mathrm{reinterpret}}}_{{\mathit{numtype}}, {\mathit{numtype}'}}(i_1)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}'}` is :math:`{\mathsf{i}}{N}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{cvtop}} = \mathsf{reinterpret}`. |
| |
| #. Assert: Due to validation, :math:`{|{\mathit{numtype}}|} = {|{\mathit{numtype}'}|}`. |
| |
| #. Return :math:`{{\mathrm{reinterpret}}}_{{\mathit{numtype}}, {\mathit{numtype}'}}(i_1)`. |
| |
| |
| :math:`{\mathrm{zeroop}}({{\mathit{lanetype}'}}{\mathsf{x}}{M_1}, {{\mathit{lanetype}}}{\mathsf{x}}{M_2}, {\mathit{vcvtop}})` |
| ............................................................................................................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}` and :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{extend}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}` and :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{convert}}{\mathsf{\_}}{{{\mathit{half}}^?}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{trunc\_sat}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}}`, then: |
| |
| 1) Let :math:`({\mathsf{trunc\_sat}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Return :math:`{{\mathit{zero}}^?}`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{relaxed\_trunc}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}}`, then: |
| |
| 1) Let :math:`({\mathsf{relaxed\_trunc}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Return :math:`{{\mathit{zero}}^?}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{demote}}{\mathsf{\_}}{\mathsf{zero}}`, then: |
| |
| a. Let :math:`({\mathsf{demote}}{\mathsf{\_}}{\mathsf{zero}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #. Return :math:`{\mathit{zero}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vcvtop}} = `. |
| |
| #. Return :math:`\epsilon`. |
| |
| |
| :math:`{\mathrm{halfop}}({{\mathit{lanetype}'}}{\mathsf{x}}{M_1}, {{\mathit{lanetype}}}{\mathsf{x}}{M_2}, {\mathit{vcvtop}})` |
| ............................................................................................................................. |
| |
| |
| 1. If :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}` and :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{extend}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{extend}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Return :math:`{\mathit{half}}`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}` and :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{convert}}{\mathsf{\_}}{{{\mathit{half}}^?}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{convert}}{\mathsf{\_}}{{{\mathit{half}}^?}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Return :math:`{{\mathit{half}}^?}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{trunc\_sat}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}}`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{relaxed\_trunc}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}}`, then: |
| |
| 1) Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{demote}}{\mathsf{\_}}{\mathsf{zero}}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vcvtop}} = `. |
| |
| #. Return :math:`\mathsf{low}`. |
| |
| |
| :math:`{\mathrm{half}}({\mathit{half}}, i, j)` |
| .............................................. |
| |
| |
| 1. If :math:`{\mathit{half}} = \mathsf{low}`, then: |
| |
| a. Return :math:`i`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{half}} = \mathsf{high}`. |
| |
| #. Return :math:`j`. |
| |
| |
| :math:`{{\mathrm{iswizzle}}_{{\mathit{lane}}}}_{N}({c^\ast}, i)` |
| ................................................................ |
| |
| |
| 1. If :math:`i < {|{c^\ast}|}`, then: |
| |
| a. Return :math:`{c^\ast}{}[i]`. |
| |
| #. Return :math:`0`. |
| |
| |
| :math:`{{\mathrm{irelaxed}}_{{\mathit{swizzle}}_{{\mathit{lane}}}}}_{N}({c^\ast}, i)` |
| ..................................................................................... |
| |
| |
| 1. If :math:`i < {|{c^\ast}|}`, then: |
| |
| a. Return :math:`{c^\ast}{}[i]`. |
| |
| #. If :math:`{{\mathrm{signed}}}_{N}(i) < 0`, then: |
| |
| a. Return :math:`0`. |
| |
| #. Return :math:`{{\mathrm{relaxed}}({\mathrm{R}}_{\mathit{swizzle}})}{{}[ 0, {c^\ast}{}[i \mathbin{\mathrm{mod}} {|{c^\ast}|}] ]}`. |
| |
| |
| :math:`{{\mathrm{ivunop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1)` |
| ................................................................................. |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{\mathrm{f}}}_{N}(c_1)`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{fvunop}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1)` |
| ................................................................................. |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{f}}}_{N}(c_1)^\ast}`. |
| |
| #. Return :math:`{{{{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| |
| :math:`{{\mathrm{ivbinop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, v_2)` |
| ....................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}` and :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{\mathrm{f}}}_{N}(c_1, c_2)`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivbinopsx}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, {\mathit{sx}}, v_1, v_2)` |
| ........................................................................................................ |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}` and :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{\mathrm{f}}}_{N}({\mathit{sx}}, c_1, c_2)`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivbinopsxnd}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, {\mathit{sx}}, v_1, v_2)` |
| .......................................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{f}}}_{N}({\mathit{sx}}, c_1, c_2)^\ast}`. |
| |
| #. Return :math:`{{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| |
| :math:`{{\mathrm{fvbinop}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, v_2)` |
| ....................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{f}}}_{N}(c_1, c_2)^\ast}`. |
| |
| #. Return :math:`{{{{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| |
| :math:`{{\mathrm{ivternopnd}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, v_2, v_3)` |
| ............................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c_3^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_3)`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{f}}}_{N}(c_1, c_2, c_3)^\ast}`. |
| |
| #. Return :math:`{{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| |
| :math:`{{\mathrm{fvternop}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, v_2, v_3)` |
| ............................................................................................. |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c_3^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_3)`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{f}}}_{N}(c_1, c_2, c_3)^\ast}`. |
| |
| #. Return :math:`{{{{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| |
| :math:`{{\mathrm{ivrelop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, v_2)` |
| ....................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}` and :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{f}}}_{N}(c_1, c_2))}`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivrelopsx}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, {\mathit{sx}}, v_1, v_2)` |
| ........................................................................................................ |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}` and :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{f}}}_{N}({\mathit{sx}}, c_1, c_2))}`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{fvrelop}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, v_2)` |
| ....................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{f}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{\mathsf{i}}{N}` be the result for which :math:`{|{\mathsf{i}}{N}|}` :math:`=` :math:`{|{\mathsf{f}}{N}|}`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}` and :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{1, N}^{\mathsf{s}}}}{({{\mathrm{f}}}_{N}(c_1, c_2))}`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivshiftop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, i)` |
| ....................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{\mathrm{f}}}_{N}(c_1, i)`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivshiftopsx}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, {\mathit{sx}}, v_1, i)` |
| ........................................................................................................ |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{\mathrm{f}}}_{N}({\mathit{sx}}, c_1, i)`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivbitmaskop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)` |
| ........................................................................ |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`c` be the result for which :math:`{{\mathrm{bits}}}_{{\mathsf{i}}{32}}(c)` :math:`=` :math:`{{{\mathrm{ilt}}}{\mathsf{s}}{{}_{N}(c_1, 0)}^\ast}~{0^{32 - M}}`. |
| |
| #. Return :math:`{{\mathrm{irev}}}_{32}(c)`. |
| |
| |
| :math:`{{\mathrm{ivswizzlop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{f}}, v_1, v_2)` |
| .......................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{{\mathrm{f}}}_{N}({c_1^\ast}, c_2)`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivshufflop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({i^\ast}, v_1, v_2)` |
| ...................................................................................... |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v_2)`. |
| |
| #. Let :math:`{c^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`i` in :math:`{i^\ast}`, do: |
| |
| a. Let :math:`c` be :math:`{c_1^\ast}~{c_2^\ast}{}[i]`. |
| |
| #. Append :math:`c` to :math:`{c^\ast}`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{\mathsf{not}}{{}_{{\mathsf{v}}{N}}(v)}` |
| ............................................... |
| |
| |
| 1. Return :math:`{{\mathrm{inot}}}_{N}(v)`. |
| |
| |
| :math:`{{\mathit{vvbinop}}}{{}_{{\mathsf{v}}{N}}(v_1, v_2)}` |
| ............................................................ |
| |
| |
| 1. If :math:`{\mathit{vvbinop}} = \mathsf{and}`, then: |
| |
| a. Return :math:`{{\mathrm{iand}}}_{N}(v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vvbinop}} = \mathsf{andnot}`, then: |
| |
| a. Return :math:`{{\mathrm{iandnot}}}_{N}(v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vvbinop}} = \mathsf{or}`, then: |
| |
| a. Return :math:`{{\mathrm{ior}}}_{N}(v_1, v_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vvbinop}} = \mathsf{xor}`. |
| |
| #. Return :math:`{{\mathrm{ixor}}}_{N}(v_1, v_2)`. |
| |
| |
| :math:`{\mathsf{bitselect}}{{}_{{\mathsf{v}}{N}}(v_1, v_2, v_3)}` |
| ................................................................. |
| |
| |
| 1. Return :math:`{{\mathrm{ibitselect}}}_{N}(v_1, v_2, v_3)`. |
| |
| |
| :math:`{{\mathit{vunop}}}{{}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(v)}` |
| ........................................................................ |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`, then: |
| |
| a. If :math:`{\mathit{vunop}} = \mathsf{abs}`, then: |
| |
| 1) Return :math:`{{\mathrm{fvunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fabs}}, v)`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{neg}`, then: |
| |
| 1) Return :math:`{{\mathrm{fvunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fneg}}, v)`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{sqrt}`, then: |
| |
| 1) Return :math:`{{\mathrm{fvunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fsqrt}}, v)`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{ceil}`, then: |
| |
| 1) Return :math:`{{\mathrm{fvunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fceil}}, v)`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{floor}`, then: |
| |
| 1) Return :math:`{{\mathrm{fvunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ffloor}}, v)`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{trunc}`, then: |
| |
| 1) Return :math:`{{\mathrm{fvunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ftrunc}}, v)`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{nearest}`, then: |
| |
| 1) Return :math:`{{\mathrm{fvunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fnearest}}, v)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{abs}`, then: |
| |
| a. Return :math:`{{\mathrm{ivunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{iabs}}, v)`. |
| |
| #. If :math:`{\mathit{vunop}} = \mathsf{neg}`, then: |
| |
| a. Return :math:`{{\mathrm{ivunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ineg}}, v)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vunop}} = \mathsf{popcnt}`. |
| |
| #. Return :math:`{{\mathrm{ivunop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ipopcnt}}, v)`. |
| |
| |
| :math:`{{\mathit{vbinop}}}{{}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(v_1, v_2)}` |
| ................................................................................ |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{vbinop}} = \mathsf{add}`, then: |
| |
| 1) Return :math:`{{\mathrm{ivbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{iadd}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{sub}`, then: |
| |
| 1) Return :math:`{{\mathrm{ivbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{isub}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{mul}`, then: |
| |
| 1) Return :math:`{{\mathrm{ivbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{imul}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{add\_sat}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{add\_sat}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Return :math:`{{\mathrm{ivbinopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{iadd}}_{{\mathit{sat}}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{sub\_sat}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{sub\_sat}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Return :math:`{{\mathrm{ivbinopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{isub}}_{{\mathit{sat}}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{min}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{min}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Return :math:`{{\mathrm{ivbinopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{imin}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}}` is some :math:`{\mathsf{max}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{max}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vbinop}}`. |
| |
| #) Return :math:`{{\mathrm{ivbinopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{imax}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = `, then: |
| |
| 1) Return :math:`{{\mathrm{ivbinopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{iavgr}}, \mathsf{u}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = `, then: |
| |
| 1) Return :math:`{{\mathrm{ivbinopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{iq{\kern-0.1em\scriptstyle 15\kern-0.1em}mulr}}_{{\mathit{sat}}}, \mathsf{s}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = `, then: |
| |
| 1) Return :math:`{{\mathrm{ivbinopsxnd}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{irelaxed}}_{{\mathit{q{\kern-0.1em\scriptstyle 15\kern-0.1em}mulr}}}, \mathsf{s}, v_1, v_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{add}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fadd}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{sub}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fsub}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{mul}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fmul}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{div}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fdiv}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{min}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fmin}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{max}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fmax}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{pmin}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fpmin}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{pmax}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fpmax}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vbinop}} = \mathsf{relaxed\_min}`, then: |
| |
| a. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{frelaxed}}_{{\mathit{min}}}, v_1, v_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vbinop}} = \mathsf{relaxed\_max}`. |
| |
| #. Return :math:`{{\mathrm{fvbinop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{frelaxed}}_{{\mathit{max}}}, v_1, v_2)`. |
| |
| |
| :math:`{{\mathit{vternop}}}{{}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(v_1, v_2, v_3)}` |
| ...................................................................................... |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}` and :math:`{\mathit{vternop}} = \mathsf{relaxed\_laneselect}`, then: |
| |
| a. Return :math:`{{\mathrm{ivternopnd}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{irelaxed}}_{{\mathit{laneselect}}}, v_1, v_2, v_3)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{vternop}} = \mathsf{relaxed\_madd}`, then: |
| |
| a. Return :math:`{{\mathrm{fvternop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{frelaxed}}_{{\mathit{madd}}}, v_1, v_2, v_3)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vternop}} = \mathsf{relaxed\_nmadd}`. |
| |
| #. Return :math:`{{\mathrm{fvternop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{frelaxed}}_{{\mathit{nmadd}}}, v_1, v_2, v_3)`. |
| |
| |
| :math:`{{\mathit{vrelop}}}{{}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}(v_1, v_2)}` |
| ................................................................................ |
| |
| |
| 1. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{vrelop}} = \mathsf{eq}`, then: |
| |
| 1) Return :math:`{{\mathrm{ivrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ieq}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{ne}`, then: |
| |
| 1) Return :math:`{{\mathrm{ivrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ine}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`{\mathsf{lt}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{lt}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Return :math:`{{\mathrm{ivrelopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ilt}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`{\mathsf{gt}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{gt}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Return :math:`{{\mathrm{ivrelopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{igt}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`{\mathsf{le}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{le}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Return :math:`{{\mathrm{ivrelopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ile}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}}` is some :math:`{\mathsf{ge}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{ge}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vrelop}}`. |
| |
| #) Return :math:`{{\mathrm{ivrelopsx}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{ige}}, {\mathit{sx}}, v_1, v_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{eq}`, then: |
| |
| a. Return :math:`{{\mathrm{fvrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{feq}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{ne}`, then: |
| |
| a. Return :math:`{{\mathrm{fvrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fne}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{lt}`, then: |
| |
| a. Return :math:`{{\mathrm{fvrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{flt}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{gt}`, then: |
| |
| a. Return :math:`{{\mathrm{fvrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fgt}}, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vrelop}} = \mathsf{le}`, then: |
| |
| a. Return :math:`{{\mathrm{fvrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fle}}, v_1, v_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vrelop}} = \mathsf{ge}`. |
| |
| #. Return :math:`{{\mathrm{fvrelop}}}_{{{\mathit{lanetype}}}{\mathsf{x}}{M}}({\mathrm{fge}}, v_1, v_2)`. |
| |
| |
| :math:`{{\mathrm{lcvtop}}}_{{{\mathit{lanetype}'}}{\mathsf{x}}{M_1}, {{\mathit{lanetype}}}{\mathsf{x}}{M_2}}({\mathit{vcvtop}}, c_1)` |
| ..................................................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}` and :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{extend}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{extend}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Let :math:`c` be :math:`{{{{\mathrm{extend}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(c_1)}`. |
| |
| #) Return :math:`c`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}` and :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{convert}}{\mathsf{\_}}{{{\mathit{half}}^?}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| 1) Let :math:`({\mathsf{convert}}{\mathsf{\_}}{{{\mathit{half}}^?}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Let :math:`c` be :math:`{{{{\mathrm{convert}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(c_1)}`. |
| |
| #) Return :math:`c`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}'}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{lanetype}}` is :math:`{\mathsf{i}}{N}`, then: |
| |
| a. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{trunc\_sat}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}}`, then: |
| |
| 1) Let :math:`({\mathsf{trunc\_sat}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Let :math:`{c^?}` be :math:`{{{{\mathrm{trunc\_sat}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(c_1)}`. |
| |
| #) Return :math:`{c^?}`. |
| |
| #. If :math:`{\mathit{vcvtop}}` is some :math:`{\mathsf{relaxed\_trunc}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}}`, then: |
| |
| 1) Let :math:`({\mathsf{relaxed\_trunc}}{\mathsf{\_}}{{\mathit{sx}}}{\mathsf{\_}}{{{\mathit{zero}}^?}})` be the destructuring of :math:`{\mathit{vcvtop}}`. |
| |
| #) Let :math:`{c^?}` be :math:`{{{{\mathrm{relaxed\_trunc}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(c_1)}`. |
| |
| #) Return :math:`{c^?}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{lanetype}}` is :math:`{\mathsf{f}}{N}`. |
| |
| #. If :math:`{\mathit{vcvtop}} = ({\mathsf{demote}}{\mathsf{\_}}{\mathsf{zero}})`, then: |
| |
| a. Let :math:`{c^\ast}` be :math:`{{\mathrm{demote}}}_{N_1, N_2}(c_1)`. |
| |
| #. Return :math:`{c^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vcvtop}} = `. |
| |
| #. Let :math:`{c^\ast}` be :math:`{{\mathrm{promote}}}_{N_1, N_2}(c_1)`. |
| |
| #. Return :math:`{c^\ast}`. |
| |
| |
| :math:`{{\mathrm{vcvtop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}}({\mathit{vcvtop}}, v_1)` |
| ................................................................................................................................... |
| |
| |
| 1. If :math:`M = {M'}` and :math:`{\mathrm{halfop}}({{{\mathsf{i}}{N}}_1}{\mathsf{x}}{{M'}}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}, {\mathit{vcvtop}})` is not defined and :math:`{\mathrm{zeroop}}({{{\mathsf{i}}{N}}_1}{\mathsf{x}}{{M'}}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}, {\mathit{vcvtop}})` is not defined, then: |
| |
| a. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{{M'}}}(v_1)`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{lcvtop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{{M'}}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}}({\mathit{vcvtop}}, c_1)^\ast}`. |
| |
| #. Let :math:`v` be an element of :math:`{{{{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| #. Return :math:`v`. |
| |
| #. If :math:`{\mathrm{halfop}}({{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}, {\mathit{vcvtop}})` is defined, then: |
| |
| a. Let :math:`{\mathit{half}}` be :math:`{\mathrm{halfop}}({{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}, {\mathit{vcvtop}})`. |
| |
| #. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}}(v_1){}[{\mathrm{half}}({\mathit{half}}, 0, {M'}) : {M'}]`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{lcvtop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}}({\mathit{vcvtop}}, c_1)^\ast}`. |
| |
| #. Let :math:`v` be an element of :math:`{{{{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| #. Return :math:`v`. |
| |
| #. Assert: Due to validation, :math:`{\mathrm{zeroop}}({{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}, {\mathit{vcvtop}}) = \mathsf{zero}`. |
| |
| #. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}}(v_1)`. |
| |
| #. Let :math:`{{c^\ast}^\ast}` be :math:`{\Large\times}~{{{\mathrm{lcvtop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}}({\mathit{vcvtop}}, c_1)^\ast}~{0^{M}}`. |
| |
| #. Let :math:`v` be an element of :math:`{{{{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_2}{\mathsf{x}}{{M'}}}^{{-1}}}}{({c^\ast})}^\ast}`. |
| |
| #. Return :math:`v`. |
| |
| |
| :math:`{{\mathit{vshiftop}}}{{}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}}{(v, i)}` |
| ............................................................................ |
| |
| |
| 1. If :math:`{\mathit{vshiftop}} = \mathsf{shl}`, then: |
| |
| a. Return :math:`{{\mathrm{ivshiftop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{ishl}}, v, i)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vshiftop}}` is some :math:`{\mathsf{shr}}{\mathsf{\_}}{{\mathit{sx}}}`. |
| |
| #. Let :math:`({\mathsf{shr}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vshiftop}}`. |
| |
| #. Return :math:`{{\mathrm{ivshiftopsx}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}({\mathrm{ishr}}, {\mathit{sx}}, v, i)`. |
| |
| |
| :math:`{\mathsf{vbitmask}}{{}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v)}` |
| ..................................................................... |
| |
| |
| 1. Return :math:`{{\mathrm{ivbitmaskop}}}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}}(v)`. |
| |
| |
| :math:`{{\mathit{vswizzlop}}}{{}_{{\mathsf{i{\scriptstyle 8}}}{\mathsf{x}}{M}}(v_1, v_2)}` |
| .......................................................................................... |
| |
| |
| 1. If :math:`{\mathit{vswizzlop}} = \mathsf{swizzle}`, then: |
| |
| a. Return :math:`{{\mathrm{ivswizzlop}}}_{{\mathsf{i{\scriptstyle 8}}}{\mathsf{x}}{M}}({\mathrm{iswizzle}}_{{\mathit{lane}}}, v_1, v_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vswizzlop}} = \mathsf{relaxed\_swizzle}`. |
| |
| #. Return :math:`{{\mathrm{ivswizzlop}}}_{{\mathsf{i{\scriptstyle 8}}}{\mathsf{x}}{M}}({\mathrm{irelaxed}}_{{\mathit{swizzle}}_{{\mathit{lane}}}}, v_1, v_2)`. |
| |
| |
| :math:`{\mathsf{vshuffle}}{{}_{{\mathsf{i{\scriptstyle 8}}}{\mathsf{x}}{M}}({i^\ast}, v_1, v_2)}` |
| ................................................................................................. |
| |
| |
| 1. Return :math:`{{\mathrm{ivshufflop}}}_{{\mathsf{i{\scriptstyle 8}}}{\mathsf{x}}{M}}({i^\ast}, v_1, v_2)`. |
| |
| |
| :math:`{\mathsf{vnarrow}}{{{}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}^{{\mathit{sx}}}}}{(v_1, v_2)}` |
| ............................................................................................................................................. |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}}(v_1)`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}}(v_2)`. |
| |
| #. Let :math:`{{c'}_1^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}`, do: |
| |
| a. Let :math:`{c'}_1` be :math:`{{{{\mathrm{narrow}}}_{{|{{\mathsf{i}}{N}}_1|}, {|{{\mathsf{i}}{N}}_2|}}^{{\mathit{sx}}}}}{c_1}`. |
| |
| #. Append :math:`{c'}_1` to :math:`{{c'}_1^\ast}`. |
| |
| #. Let :math:`{{c'}_2^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`{c'}_2` be :math:`{{{{\mathrm{narrow}}}_{{|{{\mathsf{i}}{N}}_1|}, {|{{\mathsf{i}}{N}}_2|}}^{{\mathit{sx}}}}}{c_2}`. |
| |
| #. Append :math:`{c'}_2` to :math:`{{c'}_2^\ast}`. |
| |
| #. Let :math:`v` be :math:`{{{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}^{{-1}}}}{({{c'}_1^\ast}~{{c'}_2^\ast})}`. |
| |
| #. Return :math:`v`. |
| |
| |
| :math:`{{\mathrm{ivadd\_pairwise}}}_{N}({i^\ast})` |
| .................................................. |
| |
| |
| 1. Let :math:`{j_1~j_2^\ast}` be the result for which the :ref:`concatenation <notation-concat>` of :math:`{j_1~j_2^\ast}` is :math:`{i^\ast}`. |
| |
| #. Return :math:`{{{\mathrm{iadd}}}_{N}(j_1, j_2)^\ast}`. |
| |
| |
| :math:`{{\mathrm{ivextunop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({\mathrm{f}}, {\mathit{sx}}, v_1)` |
| ................................................................................................................................................. |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}}(v_1)`. |
| |
| #. Let :math:`{{c'}_1^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}`, do: |
| |
| a. Let :math:`{c'}_1` be :math:`{{{{\mathrm{extend}}}_{N_1, N_2}^{{\mathit{sx}}}}}{(c_1)}`. |
| |
| #. Append :math:`{c'}_1` to :math:`{{c'}_1^\ast}`. |
| |
| #. Let :math:`{c^\ast}` be :math:`{{\mathrm{f}}}_{N_2}({{c'}_1^\ast})`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathsf{extadd\_pairwise}}{\mathsf{\_}}{{\mathit{sx}}}}{{}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}(v_1)}` |
| ........................................................................................................................................................... |
| |
| |
| 1. Return :math:`{{\mathrm{ivextunop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({\mathrm{ivadd}}_{{\mathit{pairwise}}}, {\mathit{sx}}, v_1)`. |
| |
| |
| :math:`{{\mathrm{ivdot}}}_{N}({i_1^\ast}, {i_2^\ast})` |
| ...................................................... |
| |
| |
| 1. Let :math:`{j_1~j_2^\ast}` be the result for which the :ref:`concatenation <notation-concat>` of :math:`{j_1~j_2^\ast}` is :math:`{{{\mathrm{imul}}}_{N}(i_1, i_2)^\ast}`. |
| |
| #. Return :math:`{{{\mathrm{iadd}}}_{N}(j_1, j_2)^\ast}`. |
| |
| |
| :math:`{{\mathrm{ivdot\_sat}}}_{N}({i_1^\ast}, {i_2^\ast})` |
| ........................................................... |
| |
| |
| 1. Let :math:`{j_1~j_2^\ast}` be the result for which the :ref:`concatenation <notation-concat>` of :math:`{j_1~j_2^\ast}` is :math:`{{{\mathrm{imul}}}_{N}(i_1, i_2)^\ast}`. |
| |
| #. Return :math:`{{{\mathrm{iadd\_sat}}}{\mathsf{s}}{{}_{N}(j_1, j_2)}^\ast}`. |
| |
| |
| :math:`{{\mathrm{ivextbinop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({\mathrm{f}}, {\mathit{sx}}_1, {\mathit{sx}}_2, i, k, v_1, v_2)` |
| ................................................................................................................................................................................ |
| |
| |
| 1. Let :math:`{c_1^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}}(v_1){}[i : k]`. |
| |
| #. Let :math:`{c_2^\ast}` be :math:`{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}}(v_2){}[i : k]`. |
| |
| #. Let :math:`{{c'}_1^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_1` in :math:`{c_1^\ast}`, do: |
| |
| a. Let :math:`{c'}_1` be :math:`{{{{\mathrm{extend}}}_{N_1, N_2}^{{\mathit{sx}}_1}}}{(c_1)}`. |
| |
| #. Append :math:`{c'}_1` to :math:`{{c'}_1^\ast}`. |
| |
| #. Let :math:`{{c'}_2^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`c_2` in :math:`{c_2^\ast}`, do: |
| |
| a. Let :math:`{c'}_2` be :math:`{{{{\mathrm{extend}}}_{N_1, N_2}^{{\mathit{sx}}_2}}}{(c_2)}`. |
| |
| #. Append :math:`{c'}_2` to :math:`{{c'}_2^\ast}`. |
| |
| #. Let :math:`{c^\ast}` be :math:`{{\mathrm{f}}}_{N_2}({{c'}_1^\ast}, {{c'}_2^\ast})`. |
| |
| #. Return :math:`{{{{\mathrm{lanes}}}_{{{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}^{{-1}}}}{({c^\ast})}`. |
| |
| |
| :math:`{{\mathrm{ivmul}}}_{N}({i_1^\ast}, {i_2^\ast})` |
| ...................................................... |
| |
| |
| 1. Return :math:`{{{\mathrm{imul}}}_{N}(i_1, i_2)^\ast}`. |
| |
| |
| :math:`{{\mathit{vextbinop}}}{{}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}(v_1, v_2)}` |
| ............................................................................................................................. |
| |
| |
| 1. If :math:`{\mathit{vextbinop}}` is some :math:`{\mathsf{extmul}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}}`, then: |
| |
| a. Let :math:`({\mathsf{extmul}}{\mathsf{\_}}{{\mathit{half}}}{\mathsf{\_}}{{\mathit{sx}}})` be the destructuring of :math:`{\mathit{vextbinop}}`. |
| |
| #. Return :math:`{{\mathrm{ivextbinop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({\mathrm{ivmul}}, {\mathit{sx}}, {\mathit{sx}}, {\mathrm{half}}({\mathit{half}}, 0, M_2), M_2, v_1, v_2)`. |
| |
| #. If :math:`{\mathit{vextbinop}} = `, then: |
| |
| a. Return :math:`{{\mathrm{ivextbinop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({\mathrm{ivdot}}, \mathsf{s}, \mathsf{s}, 0, M_1, v_1, v_2)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{vextbinop}} = `. |
| |
| #. Return :math:`{{\mathrm{ivextbinop}}}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({\mathrm{ivdot}}_{{\mathit{sat}}}, \mathsf{s}, {{\mathrm{relaxed}}({\mathrm{R}}_{\mathit{idot}})}{{}[ \mathsf{s}, \mathsf{u} ]}, 0, M_1, v_1, v_2)`. |
| |
| |
| :math:`{}{{}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}(c_1, c_2, c_3)}` |
| .............................................................................................................. |
| |
| |
| 1. Let :math:`M` be :math:`2 \, M_2`. |
| |
| #. Let :math:`{\mathsf{i}}{N}` be the result for which :math:`N` :math:`=` :math:`2 \cdot N_1`. |
| |
| #. Let :math:`{c'}` be :math:`{}{{}_{{{{\mathsf{i}}{N}}_1}{\mathsf{x}}{M_1}, {{\mathsf{i}}{N}}{\mathsf{x}}{M}}(c_1, c_2)}`. |
| |
| #. Let :math:`{c''}` be :math:`{{\mathsf{extadd\_pairwise}}{\mathsf{\_}}{\mathsf{s}}}{{}_{{{\mathsf{i}}{N}}{\mathsf{x}}{M}, {{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({c'})}`. |
| |
| #. Let :math:`c` be an element of :math:`{\mathsf{add}}{{}_{{{{\mathsf{i}}{N}}_2}{\mathsf{x}}{M_2}}({c''}, c_3)}`. |
| |
| #. Return :math:`c`. |
| |
| |
| :math:`{\mathrm{Ki}}` |
| ..................... |
| |
| |
| 1. Return :math:`1024`. |
| |
| |
| :math:`{{\mathrm{pack}}}_{{\mathit{storagetype}}}({\mathit{val}})` |
| .................................................................. |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is value type, then: |
| |
| a. Return :math:`{\mathit{val}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}}` is packed type. |
| |
| #. Assert: Due to validation, :math:`{\mathit{val}}` is some :math:`{\mathit{numtype}}{.}\mathsf{const}~{{\mathit{num}}}_{{\mathit{numtype}}}`. |
| |
| #. Let :math:`({\mathit{numtype}}_0{.}\mathsf{const}~i)` be the destructuring of :math:`{\mathit{val}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{numtype}}_0 = \mathsf{i{\scriptstyle 32}}`. |
| |
| #. Return :math:`({\mathit{storagetype}}{.}\mathsf{pack}~{{\mathrm{wrap}}}_{32, {|{\mathit{storagetype}}|}}(i))`. |
| |
| |
| :math:`{{{{\mathrm{unpack}}}_{{\mathit{storagetype}}}^{{{\mathit{sx}'}^?}}}}{({\mathit{fieldval}})}` |
| .................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{storagetype}}` is value type and :math:`{\mathit{fieldval}}` is value and :math:`{{\mathit{sx}'}^?}` is not defined, then: |
| |
| a. Return :math:`{\mathit{fieldval}}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{fieldval}}` is some :math:`{\mathit{packtype}}{.}\mathsf{pack}~{i}{N}`. |
| |
| #. Let :math:`({\mathit{packtype}}{.}\mathsf{pack}~i)` be the destructuring of :math:`{\mathit{fieldval}}`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{sx}'}^?}` is defined. |
| |
| #. Let :math:`{\mathit{sx}}` be :math:`{{\mathit{sx}'}^?}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{storagetype}} = {\mathit{packtype}}`. |
| |
| #. Return :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{{|{\mathit{packtype}}|}, 32}^{{\mathit{sx}}}}}{(i)})`. |
| |
| |
| :math:`{\mathrm{tags}}({{\mathit{externaddr}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{tag}~{\mathit{tagaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{tag}~a)` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`a~{\mathrm{tags}}({{\mathit{xa}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tags}}({{\mathit{xa}}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})` |
| ......................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{global}~{\mathit{globaladdr}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~a)` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`a~{\mathrm{globals}}({{\mathit{xa}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{globals}}({{\mathit{xa}}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})` |
| ...................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{mem}~{\mathit{memaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~a)` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`a~{\mathrm{mems}}({{\mathit{xa}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{mems}}({{\mathit{xa}}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})` |
| ........................................................ |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{table}~{\mathit{tableaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~a)` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`a~{\mathrm{tables}}({{\mathit{xa}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{tables}}({{\mathit{xa}}^\ast})`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})` |
| ....................................................... |
| |
| |
| 1. If :math:`{{\mathit{externaddr}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. If :math:`{\mathit{externaddr}}_0` is some :math:`\mathsf{func}~{\mathit{funcaddr}}`, then: |
| |
| a. Let :math:`(\mathsf{func}~a)` be the destructuring of :math:`{\mathit{externaddr}}_0`. |
| |
| #. Return :math:`a~{\mathrm{funcs}}({{\mathit{xa}}^\ast})`. |
| |
| #. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}'}^\ast}`. |
| |
| #. Return :math:`{\mathrm{funcs}}({{\mathit{xa}}^\ast})`. |
| |
| |
| :math:`(s, f){.}\mathsf{store}` |
| ............................... |
| |
| |
| 1. Return. |
| |
| |
| :math:`(s, f){.}\mathsf{frame}` |
| ............................... |
| |
| |
| 1. Return :math:`f`. |
| |
| |
| :math:`(s, f){.}\mathsf{module}{.}\mathsf{tags}` |
| ................................................ |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}{.}\mathsf{tags}`. |
| |
| |
| :math:`(s, f){.}\mathsf{module}` |
| ................................ |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}`. |
| |
| |
| :math:`(s, f){.}\mathsf{tags}` |
| .............................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{tags}`. |
| |
| |
| :math:`(s, f){.}\mathsf{globals}` |
| ................................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{globals}`. |
| |
| |
| :math:`(s, f){.}\mathsf{mems}` |
| .............................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{mems}`. |
| |
| |
| :math:`(s, f){.}\mathsf{tables}` |
| ................................ |
| |
| |
| 1. Return :math:`s{.}\mathsf{tables}`. |
| |
| |
| :math:`(s, f){.}\mathsf{funcs}` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{funcs}`. |
| |
| |
| :math:`(s, f){.}\mathsf{datas}` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{datas}`. |
| |
| |
| :math:`(s, f){.}\mathsf{elems}` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{elems}`. |
| |
| |
| :math:`(s, f){.}\mathsf{structs}` |
| ................................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{structs}`. |
| |
| |
| :math:`(s, f){.}\mathsf{arrays}` |
| ................................ |
| |
| |
| 1. Return :math:`s{.}\mathsf{arrays}`. |
| |
| |
| :math:`(s, f){.}\mathsf{exns}` |
| .............................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{exns}`. |
| |
| |
| :math:`f` |
| ......... |
| |
| |
| 1. Return :math:`z{.}\mathsf{frame}`. |
| |
| |
| :math:`z{.}\mathsf{types}{}[x]` |
| ............................... |
| |
| |
| 1. Return :math:`f{.}\mathsf{module}{.}\mathsf{types}{}[x]`. |
| |
| |
| :math:`s` |
| ......... |
| |
| |
| 1. Return :math:`z{.}\mathsf{store}`. |
| |
| |
| :math:`z{.}\mathsf{tags}{}[x]` |
| .............................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{tags}{}[f{.}\mathsf{module}{.}\mathsf{tags}{}[x]]`. |
| |
| |
| :math:`z{.}\mathsf{globals}{}[x]` |
| ................................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{globals}{}[f{.}\mathsf{module}{.}\mathsf{globals}{}[x]]`. |
| |
| |
| :math:`z{.}\mathsf{mems}{}[x]` |
| .............................. |
| |
| |
| 1. Return :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]`. |
| |
| |
| :math:`z{.}\mathsf{tables}{}[x]` |
| ................................ |
| |
| |
| 1. Return :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]`. |
| |
| |
| :math:`z{.}\mathsf{funcs}{}[x]` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{funcs}{}[f{.}\mathsf{module}{.}\mathsf{funcs}{}[x]]`. |
| |
| |
| :math:`z{.}\mathsf{datas}{}[x]` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{datas}{}[f{.}\mathsf{module}{.}\mathsf{datas}{}[x]]`. |
| |
| |
| :math:`z{.}\mathsf{elems}{}[x]` |
| ............................... |
| |
| |
| 1. Return :math:`s{.}\mathsf{elems}{}[f{.}\mathsf{module}{.}\mathsf{elems}{}[x]]`. |
| |
| |
| :math:`z{.}\mathsf{locals}{}[x]` |
| ................................ |
| |
| |
| 1. Return :math:`f{.}\mathsf{locals}{}[x]`. |
| |
| |
| :math:`z{}[{.}\mathsf{locals}{}[x] = v]` |
| ........................................ |
| |
| |
| 1. Replace :math:`f{.}\mathsf{locals}{}[x]` with :math:`v`. |
| |
| |
| :math:`z{}[{.}\mathsf{globals}{}[x]{.}\mathsf{value} = v]` |
| .......................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{globals}{}[f{.}\mathsf{module}{.}\mathsf{globals}{}[x]]{.}\mathsf{value}` with :math:`v`. |
| |
| |
| :math:`z{}[{.}\mathsf{tables}{}[x]{.}\mathsf{refs}{}[i] = r]` |
| ............................................................. |
| |
| |
| 1. Replace :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]{.}\mathsf{refs}{}[i]` with :math:`r`. |
| |
| |
| :math:`z{}[{.}\mathsf{tables}{}[x] = {\mathit{ti}}]` |
| .................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{tables}{}[f{.}\mathsf{module}{.}\mathsf{tables}{}[x]]` with :math:`{\mathit{ti}}`. |
| |
| |
| :math:`z{}[{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i : j] = {b^\ast}]` |
| ....................................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]{.}\mathsf{bytes}{}[i : j]` with :math:`{b^\ast}`. |
| |
| |
| :math:`z{}[{.}\mathsf{mems}{}[x] = {\mathit{mi}}]` |
| .................................................. |
| |
| |
| 1. Replace :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]` with :math:`{\mathit{mi}}`. |
| |
| |
| :math:`z{}[{.}\mathsf{elems}{}[x]{.}\mathsf{refs} = {r^\ast}]` |
| .............................................................. |
| |
| |
| 1. Replace :math:`s{.}\mathsf{elems}{}[f{.}\mathsf{module}{.}\mathsf{elems}{}[x]]{.}\mathsf{refs}` with :math:`{r^\ast}`. |
| |
| |
| :math:`z{}[{.}\mathsf{datas}{}[x]{.}\mathsf{bytes} = {b^\ast}]` |
| ............................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{datas}{}[f{.}\mathsf{module}{.}\mathsf{datas}{}[x]]{.}\mathsf{bytes}` with :math:`{b^\ast}`. |
| |
| |
| :math:`z{}[{.}\mathsf{structs}{}[a]{.}\mathsf{fields}{}[i] = {\mathit{fv}}]` |
| ............................................................................ |
| |
| |
| 1. Replace :math:`s{.}\mathsf{structs}{}[a]{.}\mathsf{fields}{}[i]` with :math:`{\mathit{fv}}`. |
| |
| |
| :math:`z{}[{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}{}[i] = {\mathit{fv}}]` |
| ........................................................................... |
| |
| |
| 1. Replace :math:`s{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}{}[i]` with :math:`{\mathit{fv}}`. |
| |
| |
| :math:`z{}[{.}\mathsf{structs} \mathrel{{=}{\oplus}} {{\mathit{si}}^\ast}]` |
| ........................................................................... |
| |
| |
| 1. Append :math:`{{\mathit{si}}^\ast}` to :math:`s{.}\mathsf{structs}`. |
| |
| |
| :math:`z{}[{.}\mathsf{arrays} \mathrel{{=}{\oplus}} {{\mathit{ai}}^\ast}]` |
| .......................................................................... |
| |
| |
| 1. Append :math:`{{\mathit{ai}}^\ast}` to :math:`s{.}\mathsf{arrays}`. |
| |
| |
| :math:`z{}[{.}\mathsf{exns} \mathrel{{=}{\oplus}} {{\mathit{exn}}^\ast}]` |
| ......................................................................... |
| |
| |
| 1. Append :math:`{{\mathit{exn}}^\ast}` to :math:`s{.}\mathsf{exns}`. |
| |
| |
| :math:`{\mathrm{growtable}}({\mathit{tableinst}}, n, r)` |
| ........................................................ |
| |
| |
| 1. Let :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ i .. {j^?} ]~{\mathit{rt}}),\;\allowbreak \mathsf{refs}~{{r'}^\ast} \}` be the destructuring of :math:`{\mathit{tableinst}}`. |
| |
| #. Let :math:`{i'}` be :math:`{|{{r'}^\ast}|} + n`. |
| |
| #. If not :math:`{({i'} \leq j)^?}`, then: |
| |
| a. Fail. |
| |
| #. If :math:`{i'} \leq {2^{{|{\mathit{at}}|}}} - 1`, then: |
| |
| a. Let :math:`{\mathit{tableinst}'}` be the table instance :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ {i'} .. {j^?} ]~{\mathit{rt}}),\;\allowbreak \mathsf{refs}~{{r'}^\ast}~{r^{n}} \}`. |
| |
| #. Return :math:`{\mathit{tableinst}'}`. |
| |
| #. Fail. |
| |
| |
| :math:`{\mathrm{growmem}}({\mathit{meminst}}, n)` |
| ................................................. |
| |
| |
| 1. Let :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ i .. {j^?} ]~\mathsf{page}),\;\allowbreak \mathsf{bytes}~{b^\ast} \}` be the destructuring of :math:`{\mathit{meminst}}`. |
| |
| #. Let :math:`{i'}` be :math:`{|{b^\ast}|} / (64 \, {\mathrm{Ki}}) + n`. |
| |
| #. If not :math:`{({i'} \leq j)^?}`, then: |
| |
| a. Fail. |
| |
| #. If :math:`{i'} \leq {2^{{|{\mathit{at}}|} - 16}}`, then: |
| |
| a. Let :math:`{\mathit{meminst}'}` be the memory instance :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ {i'} .. {j^?} ]~\mathsf{page}),\;\allowbreak \mathsf{bytes}~{b^\ast}~{\mathtt{0x00}^{n \cdot 64 \, {\mathrm{Ki}}}} \}`. |
| |
| #. Return :math:`{\mathit{meminst}'}`. |
| |
| #. Fail. |
| |
| |
| :math:`{{\mathrm{inst}}}_{{\mathit{moduleinst}}}(t)` |
| .................................................... |
| |
| |
| 1. Return :math:`{t}{{}[ {:=}\, {\mathit{moduleinst}}{.}\mathsf{types} ]}`. |
| |
| |
| :math:`{{\mathrm{inst}}}_{{\mathit{moduleinst}}}({\mathit{rt}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`{{\mathit{rt}}}{{}[ {:=}\, {\mathit{moduleinst}}{.}\mathsf{types} ]}`. |
| |
| |
| :math:`{{\mathrm{inst}}}_{{\mathit{moduleinst}}}({\mathit{gt}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`{{\mathit{gt}}}{{}[ {:=}\, {\mathit{moduleinst}}{.}\mathsf{types} ]}`. |
| |
| |
| :math:`{{\mathrm{inst}}}_{{\mathit{moduleinst}}}({\mathit{mt}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`{{\mathit{mt}}}{{}[ {:=}\, {\mathit{moduleinst}}{.}\mathsf{types} ]}`. |
| |
| |
| :math:`{{\mathrm{inst}}}_{{\mathit{moduleinst}}}({\mathit{tt}})` |
| ................................................................ |
| |
| |
| 1. Return :math:`{{\mathit{tt}}}{{}[ {:=}\, {\mathit{moduleinst}}{.}\mathsf{types} ]}`. |
| |
| |
| :math:`{{\mathrm{blocktype}}}_{z}({\mathit{blocktype}})` |
| ........................................................ |
| |
| |
| 1. If :math:`{\mathit{blocktype}}` is some :math:`{\mathit{typeidx}}`, then: |
| |
| a. Let :math:`x` be the block type :math:`{\mathit{blocktype}}`. |
| |
| #. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`z{.}\mathsf{types}{}[x]`. |
| |
| #. Return :math:`{t_1^\ast}~{\rightarrow}_{\epsilon}\,{t_2^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{blocktype}}` is some :math:`{{\mathit{valtype}}^?}`. |
| |
| #. Let :math:`{t^?}` be the block type :math:`{\mathit{blocktype}}`. |
| |
| #. Return :math:`\epsilon~{\rightarrow}_{\epsilon}\,{t^?}`. |
| |
| |
| :math:`{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}''}^\ast})}` |
| ................................................................. |
| |
| |
| 1. If :math:`{{\mathit{type}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{{\mathit{type}'}^\ast}~{\mathit{type}}` be :math:`{{\mathit{type}''}^\ast}`. |
| |
| #. Let :math:`(\mathsf{type}~{\mathit{rectype}})` be the destructuring of :math:`{\mathit{type}}`. |
| |
| #. Let :math:`{{\mathit{deftype}'}^\ast}` be :math:`{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}'}^\ast})}`. |
| |
| #. Let :math:`x` be the length of :math:`{{\mathit{deftype}'}^\ast}`. |
| |
| #. Let :math:`{{\mathit{deftype}}^\ast}` be :math:`{{{{{\mathrm{roll}}}_{x}^\ast}}{({\mathit{rectype}})}}{{}[ {:=}\, {{\mathit{deftype}'}^\ast} ]}`. |
| |
| #. Return :math:`{{\mathit{deftype}'}^\ast}~{{\mathit{deftype}}^\ast}`. |
| |
| |
| :math:`{\mathrm{alloctag}}(s, {\mathit{tagtype}})` |
| .................................................. |
| |
| |
| 1. Let :math:`{\mathit{taginst}}` be the tag instance :math:`\{ \mathsf{type}~{\mathit{tagtype}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{tags}`. |
| |
| #. Append :math:`{\mathit{taginst}}` to :math:`s{.}\mathsf{tags}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{{{\mathrm{alloctag}}^\ast}}{(s, {{\mathit{tagtype}''}^\ast})}` |
| ...................................................................... |
| |
| |
| 1. If :math:`{{\mathit{tagtype}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{tagtype}}~{{\mathit{tagtype}'}^\ast}` be :math:`{{\mathit{tagtype}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ja}}` be :math:`{\mathrm{alloctag}}(s, {\mathit{tagtype}})`. |
| |
| #. Let :math:`{{\mathit{ja}'}^\ast}` be :math:`{{{\mathrm{alloctag}}^\ast}}{(s, {{\mathit{tagtype}'}^\ast})}`. |
| |
| #. Return :math:`{\mathit{ja}}~{{\mathit{ja}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocglobal}}(s, {\mathit{globaltype}}, {\mathit{val}})` |
| ........................................................................ |
| |
| |
| 1. Let :math:`{\mathit{globalinst}}` be the global instance :math:`\{ \mathsf{type}~{\mathit{globaltype}},\;\allowbreak \mathsf{value}~{\mathit{val}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{globals}`. |
| |
| #. Append :math:`{\mathit{globalinst}}` to :math:`s{.}\mathsf{globals}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{{{\mathrm{allocglobal}}^\ast}}{(s, {{\mathit{globaltype}''}^\ast}, {{\mathit{val}''}^\ast})}` |
| ..................................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{globaltype}''}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{\mathit{val}''}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{globaltype}}~{{\mathit{globaltype}'}^\ast}` be :math:`{{\mathit{globaltype}''}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{val}''}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{val}}~{{\mathit{val}'}^\ast}` be :math:`{{\mathit{val}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ga}}` be :math:`{\mathrm{allocglobal}}(s, {\mathit{globaltype}}, {\mathit{val}})`. |
| |
| #. Let :math:`{{\mathit{ga}'}^\ast}` be :math:`{{{\mathrm{allocglobal}}^\ast}}{(s, {{\mathit{globaltype}'}^\ast}, {{\mathit{val}'}^\ast})}`. |
| |
| #. Return :math:`{\mathit{ga}}~{{\mathit{ga}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocmem}}(s, {\mathit{at}}~{}[ i .. {j^?} ]~\mathsf{page})` |
| ............................................................................ |
| |
| |
| 1. Let :math:`{\mathit{meminst}}` be the memory instance :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ i .. {j^?} ]~\mathsf{page}),\;\allowbreak \mathsf{bytes}~{\mathtt{0x00}^{i \cdot 64 \, {\mathrm{Ki}}}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{mems}`. |
| |
| #. Append :math:`{\mathit{meminst}}` to :math:`s{.}\mathsf{mems}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{{{\mathrm{allocmem}}^\ast}}{(s, {{\mathit{memtype}''}^\ast})}` |
| ...................................................................... |
| |
| |
| 1. If :math:`{{\mathit{memtype}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{memtype}}~{{\mathit{memtype}'}^\ast}` be :math:`{{\mathit{memtype}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ma}}` be :math:`{\mathrm{allocmem}}(s, {\mathit{memtype}})`. |
| |
| #. Let :math:`{{\mathit{ma}'}^\ast}` be :math:`{{{\mathrm{allocmem}}^\ast}}{(s, {{\mathit{memtype}'}^\ast})}`. |
| |
| #. Return :math:`{\mathit{ma}}~{{\mathit{ma}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{alloctable}}(s, {\mathit{at}}~{}[ i .. {j^?} ]~{\mathit{rt}}, {\mathit{ref}})` |
| .............................................................................................. |
| |
| |
| 1. Let :math:`{\mathit{tableinst}}` be the table instance :math:`\{ \mathsf{type}~({\mathit{at}}~{}[ i .. {j^?} ]~{\mathit{rt}}),\;\allowbreak \mathsf{refs}~{{\mathit{ref}}^{i}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{tables}`. |
| |
| #. Append :math:`{\mathit{tableinst}}` to :math:`s{.}\mathsf{tables}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{{{\mathrm{alloctable}}^\ast}}{(s, {{\mathit{tabletype}''}^\ast}, {{\mathit{ref}''}^\ast})}` |
| ................................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{ref}''}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{\mathit{tabletype}''}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{ref}}~{{\mathit{ref}'}^\ast}` be :math:`{{\mathit{ref}''}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{tabletype}''}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{tabletype}}~{{\mathit{tabletype}'}^\ast}` be :math:`{{\mathit{tabletype}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ta}}` be :math:`{\mathrm{alloctable}}(s, {\mathit{tabletype}}, {\mathit{ref}})`. |
| |
| #. Let :math:`{{\mathit{ta}'}^\ast}` be :math:`{{{\mathrm{alloctable}}^\ast}}{(s, {{\mathit{tabletype}'}^\ast}, {{\mathit{ref}'}^\ast})}`. |
| |
| #. Return :math:`{\mathit{ta}}~{{\mathit{ta}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocfunc}}(s, {\mathit{deftype}}, {\mathit{code}}, {\mathit{moduleinst}})` |
| ........................................................................................... |
| |
| |
| 1. Let :math:`{\mathit{funcinst}}` be the function instance :math:`\{ \mathsf{type}~{\mathit{deftype}},\;\allowbreak \mathsf{module}~{\mathit{moduleinst}},\;\allowbreak \mathsf{code}~{\mathit{code}} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{funcs}`. |
| |
| #. Append :math:`{\mathit{funcinst}}` to :math:`s{.}\mathsf{funcs}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{{{\mathrm{allocfunc}}^\ast}}{(s, {{\mathit{deftype}}^\ast}, {{{\mathit{code}}''}^\ast}, {{\mathit{moduleinst}''}^\ast})}` |
| ................................................................................................................................. |
| |
| |
| 1. If :math:`{{\mathit{deftype}}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{{\mathit{code}}''}^\ast} = \epsilon`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{moduleinst}''}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{dt}}~{{\mathit{dt}'}^\ast}` be :math:`{{\mathit{deftype}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{{\mathit{code}}''}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{code}}~{{{\mathit{code}}'}^\ast}` be :math:`{{{\mathit{code}}''}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{moduleinst}''}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{moduleinst}}~{{\mathit{moduleinst}'}^\ast}` be :math:`{{\mathit{moduleinst}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{fa}}` be :math:`{\mathrm{allocfunc}}(s, {\mathit{dt}}, {\mathit{code}}, {\mathit{moduleinst}})`. |
| |
| #. Let :math:`{{\mathit{fa}'}^\ast}` be :math:`{{{\mathrm{allocfunc}}^\ast}}{(s, {{\mathit{dt}'}^\ast}, {{{\mathit{code}}'}^\ast}, {{\mathit{moduleinst}'}^\ast})}`. |
| |
| #. Return :math:`{\mathit{fa}}~{{\mathit{fa}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocdata}}(s, \mathsf{ok}, {{\mathit{byte}}^\ast})` |
| .................................................................... |
| |
| |
| 1. Let :math:`{\mathit{datainst}}` be the data instance :math:`\{ \mathsf{bytes}~{{\mathit{byte}}^\ast} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{datas}`. |
| |
| #. Append :math:`{\mathit{datainst}}` to :math:`s{.}\mathsf{datas}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{{{\mathrm{allocdata}}^\ast}}{(s, {{\mathit{datatype}}^\ast}, {{\mathit{byte}}^\ast})}` |
| .............................................................................................. |
| |
| |
| 1. If :math:`{{\mathit{byte}}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{\mathit{datatype}}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{b^\ast}~{{{b'}^\ast}^\ast}` be :math:`{{\mathit{byte}}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{datatype}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{ok}}~{{\mathit{ok}'}^\ast}` be :math:`{{\mathit{datatype}}^\ast}`. |
| |
| #. Let :math:`{\mathit{da}}` be :math:`{\mathrm{allocdata}}(s, {\mathit{ok}}, {b^\ast})`. |
| |
| #. Let :math:`{{\mathit{da}'}^\ast}` be :math:`{{{\mathrm{allocdata}}^\ast}}{(s, {{\mathit{ok}'}^\ast}, {{{b'}^\ast}^\ast})}`. |
| |
| #. Return :math:`{\mathit{da}}~{{\mathit{da}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocelem}}(s, {\mathit{elemtype}}, {{\mathit{ref}}^\ast})` |
| ........................................................................... |
| |
| |
| 1. Let :math:`{\mathit{eleminst}}` be the element instance :math:`\{ \mathsf{type}~{\mathit{elemtype}},\;\allowbreak \mathsf{refs}~{{\mathit{ref}}^\ast} \}`. |
| |
| #. Let :math:`a` be the length of :math:`s{.}\mathsf{elems}`. |
| |
| #. Append :math:`{\mathit{eleminst}}` to :math:`s{.}\mathsf{elems}`. |
| |
| #. Return :math:`a`. |
| |
| |
| :math:`{{{\mathrm{allocelem}}^\ast}}{(s, {{\mathit{elemtype}}^\ast}, {{\mathit{ref}''}^\ast})}` |
| ............................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{ref}''}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{\mathit{elemtype}}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{{\mathit{ref}}^\ast}~{{{\mathit{ref}'}^\ast}^\ast}` be :math:`{{\mathit{ref}''}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{elemtype}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{rt}}~{{\mathit{rt}'}^\ast}` be :math:`{{\mathit{elemtype}}^\ast}`. |
| |
| #. Let :math:`{\mathit{ea}}` be :math:`{\mathrm{allocelem}}(s, {\mathit{rt}}, {{\mathit{ref}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ea}'}^\ast}` be :math:`{{{\mathrm{allocelem}}^\ast}}{(s, {{\mathit{rt}'}^\ast}, {{{\mathit{ref}'}^\ast}^\ast})}`. |
| |
| #. Return :math:`{\mathit{ea}}~{{\mathit{ea}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{allocexport}}({\mathit{moduleinst}}, \mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` |
| ........................................................................................................... |
| |
| |
| 1. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{tag}~{\mathit{tagidx}}`, then: |
| |
| a. Let :math:`(\mathsf{tag}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{tag}~{\mathit{moduleinst}}{.}\mathsf{tags}{}[x]) \}`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{global}~{\mathit{globalidx}}`, then: |
| |
| a. Let :math:`(\mathsf{global}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{global}~{\mathit{moduleinst}}{.}\mathsf{globals}{}[x]) \}`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{mem}~{\mathit{memidx}}`, then: |
| |
| a. Let :math:`(\mathsf{mem}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{mem}~{\mathit{moduleinst}}{.}\mathsf{mems}{}[x]) \}`. |
| |
| #. If :math:`{\mathit{externidx}}` is some :math:`\mathsf{table}~{\mathit{tableidx}}`, then: |
| |
| a. Let :math:`(\mathsf{table}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{table}~{\mathit{moduleinst}}{.}\mathsf{tables}{}[x]) \}`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{externidx}}` is some :math:`\mathsf{func}~{\mathit{funcidx}}`. |
| |
| #. Let :math:`(\mathsf{func}~x)` be the destructuring of :math:`{\mathit{externidx}}`. |
| |
| #. Return :math:`\{ \mathsf{name}~{\mathit{name}},\;\allowbreak \mathsf{addr}~(\mathsf{func}~{\mathit{moduleinst}}{.}\mathsf{funcs}{}[x]) \}`. |
| |
| |
| :math:`{{{\mathrm{allocexport}}^\ast}}{({\mathit{moduleinst}}, {{\mathit{export}}^\ast})}` |
| .......................................................................................... |
| |
| |
| 1. Return :math:`{{\mathrm{allocexport}}({\mathit{moduleinst}}, {\mathit{export}})^\ast}`. |
| |
| |
| :math:`{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})` |
| ..................................................................................................................................................................................................... |
| |
| |
| 1. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be the destructuring of :math:`{\mathit{module}}`. |
| |
| #. Let :math:`{{\mathit{aa}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{tags}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ga}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{fa}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ma}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{ta}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externaddr}}^\ast})`. |
| |
| #. Let :math:`{{\mathit{fa}}^\ast}` be :math:`{|s{.}\mathsf{funcs}|} + i_{\mathsf{f}}` for all :math:`i_{\mathsf{f}}` from :math:`0` to :math:`{|{{\mathit{func}}^\ast}|} - 1`. |
| |
| #. Let :math:`{{\mathit{tagtype}}^\ast}` be the tag type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{tag}}` in :math:`{{\mathit{tag}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{tag}~{\mathit{tagtype}})` be the destructuring of :math:`{\mathit{tag}}`. |
| |
| #. Append :math:`{\mathit{tagtype}}` to :math:`{{\mathit{tagtype}}^\ast}`. |
| |
| #. Let :math:`{{{\mathit{byte}}^\ast}^\ast}` be the byte sequence sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{data}}` in :math:`{{\mathit{data}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}})` be the destructuring of :math:`{\mathit{data}}`. |
| |
| #. Append :math:`{{\mathit{byte}}^\ast}` to :math:`{{{\mathit{byte}}^\ast}^\ast}`. |
| |
| #. Let :math:`{{\mathit{globaltype}}^\ast}` be the global type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{global}}` in :math:`{{\mathit{global}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_{\mathsf{g}})` be the destructuring of :math:`{\mathit{global}}`. |
| |
| #. Append :math:`{\mathit{globaltype}}` to :math:`{{\mathit{globaltype}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{tabletype}}^\ast}` be the table type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{table}}` in :math:`{{\mathit{table}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}}_{\mathsf{t}})` be the destructuring of :math:`{\mathit{table}}`. |
| |
| #. Append :math:`{\mathit{tabletype}}` to :math:`{{\mathit{tabletype}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{memtype}}^\ast}` be the memory type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{mem}}` in :math:`{{\mathit{mem}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{memory}~{\mathit{memtype}})` be the destructuring of :math:`{\mathit{mem}}`. |
| |
| #. Append :math:`{\mathit{memtype}}` to :math:`{{\mathit{memtype}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{dt}}^\ast}` be :math:`{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}}^\ast})}`. |
| |
| #. Let :math:`{{\mathit{elemtype}}^\ast}` be the reference type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{elem}}` in :math:`{{\mathit{elem}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{elem}~{\mathit{elemtype}}~{{\mathit{expr}}_{\mathsf{e}}^\ast}~{\mathit{elemmode}})` be the destructuring of :math:`{\mathit{elem}}`. |
| |
| #. Append :math:`{\mathit{elemtype}}` to :math:`{{\mathit{elemtype}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{expr}}_{\mathsf{f}}^\ast}` be the expression sequence :math:`\epsilon`. |
| |
| #. Let :math:`{{{\mathit{local}}^\ast}^\ast}` be the local sequence sequence :math:`\epsilon`. |
| |
| #. Let :math:`{x^\ast}` be the type index sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{func}}` in :math:`{{\mathit{func}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}}_{\mathsf{f}})` be the destructuring of :math:`{\mathit{func}}`. |
| |
| #. Append :math:`{\mathit{expr}}_{\mathsf{f}}` to :math:`{{\mathit{expr}}_{\mathsf{f}}^\ast}`. |
| |
| #. Append :math:`{{\mathit{local}}^\ast}` to :math:`{{{\mathit{local}}^\ast}^\ast}`. |
| |
| #. Append :math:`x` to :math:`{x^\ast}`. |
| |
| #. Let :math:`{{\mathit{aa}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{tagtype}}` in :math:`{{\mathit{tagtype}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{aa}}` be the tag address :math:`{\mathrm{alloctag}}(s, {{\mathit{tagtype}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]})`. |
| |
| #. Append :math:`{\mathit{aa}}` to :math:`{{\mathit{aa}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{ga}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{globaltype}}` in :math:`{{\mathit{globaltype}}^\ast}` and :math:`{\mathit{val}}_{\mathsf{g}}` in :math:`{{\mathit{val}}_{\mathsf{g}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{ga}}` be the global address :math:`{\mathrm{allocglobal}}(s, {{\mathit{globaltype}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]}, {\mathit{val}}_{\mathsf{g}})`. |
| |
| #. Append :math:`{\mathit{ga}}` to :math:`{{\mathit{ga}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{ma}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{memtype}}` in :math:`{{\mathit{memtype}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{ma}}` be the memory address :math:`{\mathrm{allocmem}}(s, {{\mathit{memtype}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]})`. |
| |
| #. Append :math:`{\mathit{ma}}` to :math:`{{\mathit{ma}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{ta}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{tabletype}}` in :math:`{{\mathit{tabletype}}^\ast}` and :math:`{\mathit{ref}}_{\mathsf{t}}` in :math:`{{\mathit{ref}}_{\mathsf{t}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{ta}}` be the table address :math:`{\mathrm{alloctable}}(s, {{\mathit{tabletype}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]}, {\mathit{ref}}_{\mathsf{t}})`. |
| |
| #. Append :math:`{\mathit{ta}}` to :math:`{{\mathit{ta}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{xi}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{export}}` in :math:`{{\mathit{export}}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{xi}}` be the export instance :math:`{\mathrm{allocexport}}({\mathit{moduleinst}}, {\mathit{export}})`. |
| |
| #. Append :math:`{\mathit{xi}}` to :math:`{{\mathit{xi}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{da}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{{\mathit{byte}}^\ast}` in :math:`{{{\mathit{byte}}^\ast}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{da}}` be the data address :math:`{\mathrm{allocdata}}(s, \mathsf{ok}, {{\mathit{byte}}^\ast})`. |
| |
| #. Append :math:`{\mathit{da}}` to :math:`{{\mathit{da}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{ea}}^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{elemtype}}` in :math:`{{\mathit{elemtype}}^\ast}` and :math:`{{\mathit{ref}}_{\mathsf{e}}^\ast}` in :math:`{{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast}`, do: |
| |
| a. Let :math:`{\mathit{ea}}` be the elem address :math:`{\mathrm{allocelem}}(s, {{\mathit{elemtype}}}{{}[ {:=}\, {{\mathit{dt}}^\ast} ]}, {{\mathit{ref}}_{\mathsf{e}}^\ast})`. |
| |
| #. Append :math:`{\mathit{ea}}` to :math:`{{\mathit{ea}}^\ast}`. |
| |
| #. Let :math:`{\mathit{moduleinst}}` be the module instance :math:`\{ \mathsf{types}~{{\mathit{dt}}^\ast},\;\allowbreak \mathsf{tags}~{{\mathit{aa}}_{\mathsf{i}}^\ast}~{{\mathit{aa}}^\ast},\;\allowbreak \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\;\allowbreak \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast},\;\allowbreak \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\;\allowbreak \mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\;\allowbreak \mathsf{datas}~{{\mathit{da}}^\ast},\;\allowbreak \mathsf{elems}~{{\mathit{ea}}^\ast},\;\allowbreak \mathsf{exports}~{{\mathit{xi}}^\ast} \}`. |
| |
| #. Let :math:`{{\mathit{funcaddr}}_0^\ast}` be :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{expr}}_{\mathsf{f}}` in :math:`{{\mathit{expr}}_{\mathsf{f}}^\ast}` and :math:`{{\mathit{local}}^\ast}` in :math:`{{{\mathit{local}}^\ast}^\ast}` and :math:`x` in :math:`{x^\ast}`, do: |
| |
| a. Let :math:`{\mathit{funcaddr}}_0` be the function address :math:`{\mathrm{allocfunc}}(s, {{\mathit{dt}}^\ast}{}[x], \mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}}_{\mathsf{f}}, {\mathit{moduleinst}})`. |
| |
| #. Append :math:`{\mathit{funcaddr}}_0` to :math:`{{\mathit{funcaddr}}_0^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{{\mathit{funcaddr}}_0^\ast} = {{\mathit{fa}}^\ast}`. |
| |
| #. Return :math:`{\mathit{moduleinst}}`. |
| |
| |
| :math:`{{\mathrm{rundata}}}_{x}(\mathsf{data}~{b^{n}}~{\mathit{datamode}})` |
| ........................................................................... |
| |
| |
| 1. If :math:`{\mathit{datamode}} = \mathsf{passive}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{datamode}}` is some :math:`\mathsf{active}~{\mathit{memidx}}~{\mathit{expr}}`. |
| |
| #. Let :math:`(\mathsf{active}~y~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{datamode}}`. |
| |
| #. Return :math:`{{\mathit{instr}}^\ast}~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)~(\mathsf{memory{.}init}~y~x)~(\mathsf{data{.}drop}~x)`. |
| |
| |
| :math:`{{\mathrm{runelem}}}_{x}(\mathsf{elem}~{\mathit{rt}}~{e^{n}}~{\mathit{elemmode}})` |
| ......................................................................................... |
| |
| |
| 1. If :math:`{\mathit{elemmode}} = \mathsf{passive}`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. If :math:`{\mathit{elemmode}} = \mathsf{declare}`, then: |
| |
| a. Return :math:`(\mathsf{elem{.}drop}~x)`. |
| |
| #. Assert: Due to validation, :math:`{\mathit{elemmode}}` is some :math:`\mathsf{active}~{\mathit{tableidx}}~{\mathit{expr}}`. |
| |
| #. Let :math:`(\mathsf{active}~y~{{\mathit{instr}}^\ast})` be the destructuring of :math:`{\mathit{elemmode}}`. |
| |
| #. Return :math:`{{\mathit{instr}}^\ast}~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)~(\mathsf{table{.}init}~y~x)~(\mathsf{elem{.}drop}~x)`. |
| |
| |
| :math:`{{{\mathrm{evalexpr}}^\ast}}{(z, {{\mathit{expr}''}^\ast})}` |
| ................................................................... |
| |
| |
| 1. If :math:`{{\mathit{expr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{expr}}~{{\mathit{expr}'}^\ast}` be :math:`{{\mathit{expr}''}^\ast}`. |
| |
| #. Let :math:`{\mathit{ref}}` be the result of :ref:`evaluating <exec-expr>` :math:`{\mathit{expr}}` with state :math:`z`. |
| |
| #. Let :math:`{{\mathit{ref}'}^\ast}` be :math:`{{{\mathrm{evalexpr}}^\ast}}{(z, {{\mathit{expr}'}^\ast})}`. |
| |
| #. Return :math:`{\mathit{ref}}~{{\mathit{ref}'}^\ast}`. |
| |
| |
| :math:`{{{{\mathrm{evalexpr}}^\ast}^\ast}}{(z, {{\mathit{expr}''}^\ast})}` |
| .......................................................................... |
| |
| |
| 1. If :math:`{{\mathit{expr}''}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{{\mathit{expr}}^\ast}~{{{\mathit{expr}'}^\ast}^\ast}` be :math:`{{\mathit{expr}''}^\ast}`. |
| |
| #. Let :math:`{{\mathit{ref}}^\ast}` be :math:`{{{\mathrm{evalexpr}}^\ast}}{(z, {{\mathit{expr}}^\ast})}`. |
| |
| #. Let :math:`{{{\mathit{ref}'}^\ast}^\ast}` be :math:`{{{{\mathrm{evalexpr}}^\ast}^\ast}}{(z, {{{\mathit{expr}'}^\ast}^\ast})}`. |
| |
| #. Return :math:`{{\mathit{ref}}^\ast}~{{{\mathit{ref}'}^\ast}^\ast}`. |
| |
| |
| :math:`{{{\mathrm{evalglobal}}^\ast}}{(z, {{\mathit{globaltype}}^\ast}, {{\mathit{expr}''}^\ast})}` |
| ................................................................................................... |
| |
| |
| 1. If :math:`{{\mathit{expr}''}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{\mathit{globaltype}}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`{\mathit{expr}}~{{\mathit{expr}'}^\ast}` be :math:`{{\mathit{expr}''}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{\mathit{globaltype}}^\ast}|} \geq 1`. |
| |
| #. Let :math:`{\mathit{gt}}~{{\mathit{gt}'}^\ast}` be :math:`{{\mathit{globaltype}}^\ast}`. |
| |
| #. Let :math:`{\mathit{val}}` be the result of :ref:`evaluating <exec-expr>` :math:`{\mathit{expr}}` with state :math:`z`. |
| |
| #. Let :math:`(s, f)` be the destructuring of :math:`z`. |
| |
| #. Let :math:`a` be :math:`{\mathrm{allocglobal}}(s, {\mathit{gt}}, {\mathit{val}})`. |
| |
| #. Append :math:`a` to :math:`f{.}\mathsf{module}{.}\mathsf{globals}`. |
| |
| #. Let :math:`{{\mathit{val}'}^\ast}` be :math:`{{{\mathrm{evalglobal}}^\ast}}{((s, f), {{\mathit{gt}'}^\ast}, {{\mathit{expr}'}^\ast})}`. |
| |
| #. Return :math:`{\mathit{val}}~{{\mathit{val}'}^\ast}`. |
| |
| |
| :math:`{\mathrm{instantiate}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast})` |
| .................................................................................. |
| |
| |
| 1. If :math:`{\mathit{module}}` is not :ref:`valid <valid-val>`, then: |
| |
| a. Fail. |
| |
| #. Let :math:`{{\mathit{xt}}_{\mathsf{i}}^\ast}~\rightarrow~{{\mathit{xt}}_{\mathsf{e}}^\ast}` be the destructuring of the type of :math:`{\mathit{module}}`. |
| |
| #. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be the destructuring of :math:`{\mathit{module}}`. |
| |
| #. If :math:`{|{{\mathit{externaddr}}^\ast}|} \neq {|{{\mathit{xt}}_{\mathsf{i}}^\ast}|}`, then: |
| |
| a. Fail. |
| |
| #. For all :math:`{\mathit{externaddr}}` in :math:`{{\mathit{externaddr}}^\ast}`, and corresponding :math:`{\mathit{xt}}_{\mathsf{i}}` in :math:`{{\mathit{xt}}_{\mathsf{i}}^\ast}`: |
| |
| a. If :math:`{\mathit{externaddr}}` is not :ref:`valid <valid-val>` with type :math:`{\mathit{xt}}_{\mathsf{i}}`, then: |
| |
| 1) Fail. |
| |
| #. Let :math:`{{\mathit{instr}}_{\mathsf{d}}^\ast}` be the :ref:`concatenation <notation-concat>` of :math:`{{{\mathrm{rundata}}}_{i_{\mathsf{d}}}({{\mathit{data}}^\ast}{}[i_{\mathsf{d}}])^{i_{\mathsf{d}}<{|{{\mathit{data}}^\ast}|}}}`. |
| |
| #. Let :math:`{{\mathit{instr}}_{\mathsf{e}}^\ast}` be the :ref:`concatenation <notation-concat>` of :math:`{{{\mathrm{runelem}}}_{i_{\mathsf{e}}}({{\mathit{elem}}^\ast}{}[i_{\mathsf{e}}])^{i_{\mathsf{e}}<{|{{\mathit{elem}}^\ast}|}}}`. |
| |
| #. Let :math:`{\mathit{moduleinst}}_0` be the module instance :math:`\{ \mathsf{types}~{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}}^\ast})},\;\allowbreak \mathsf{globals}~{\mathrm{globals}}({{\mathit{externaddr}}^\ast}),\;\allowbreak \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})~{({|s{.}\mathsf{funcs}|} + i_{\mathsf{f}})^{i_{\mathsf{f}}<{|{{\mathit{func}}^\ast}|}}} \}`. |
| |
| #. Let :math:`{{\mathit{expr}}_{\mathsf{t}}^\ast}` be the expression sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{table}}` in :math:`{{\mathit{table}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}}_{\mathsf{t}})` be the destructuring of :math:`{\mathit{table}}`. |
| |
| #. Append :math:`{\mathit{expr}}_{\mathsf{t}}` to :math:`{{\mathit{expr}}_{\mathsf{t}}^\ast}`. |
| |
| #. Let :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}` be the expression sequence :math:`\epsilon`. |
| |
| #. Let :math:`{{\mathit{globaltype}}^\ast}` be the global type sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{global}}` in :math:`{{\mathit{global}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_{\mathsf{g}})` be the destructuring of :math:`{\mathit{global}}`. |
| |
| #. Append :math:`{\mathit{expr}}_{\mathsf{g}}` to :math:`{{\mathit{expr}}_{\mathsf{g}}^\ast}`. |
| |
| #. Append :math:`{\mathit{globaltype}}` to :math:`{{\mathit{globaltype}}^\ast}`. |
| |
| #. Let :math:`{{{\mathit{expr}}_{\mathsf{e}}^\ast}^\ast}` be the expression sequence sequence :math:`\epsilon`. |
| |
| #. For each :math:`{\mathit{elem}}` in :math:`{{\mathit{elem}}^\ast}`, do: |
| |
| a. Let :math:`(\mathsf{elem}~{\mathit{reftype}}~{{\mathit{expr}}_{\mathsf{e}}^\ast}~{\mathit{elemmode}})` be the destructuring of :math:`{\mathit{elem}}`. |
| |
| #. Append :math:`{{\mathit{expr}}_{\mathsf{e}}^\ast}` to :math:`{{{\mathit{expr}}_{\mathsf{e}}^\ast}^\ast}`. |
| |
| #. Let :math:`z` be the state :math:`(s, \{ \mathsf{module}~{\mathit{moduleinst}}_0 \})`. |
| |
| #. Let :math:`F` be the :math:`\mathsf{frame}` :math:`z{.}\mathsf{frame}`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`F`. |
| |
| #. Let :math:`{{\mathit{val}}_{\mathsf{g}}^\ast}` be :math:`{{{\mathrm{evalglobal}}^\ast}}{(z, {{\mathit{globaltype}}^\ast}, {{\mathit{expr}}_{\mathsf{g}}^\ast})}`. |
| |
| #. Let :math:`{{\mathit{ref}}_{\mathsf{t}}^\ast}` be :math:`{{{\mathrm{evalexpr}}^\ast}}{(z, {{\mathit{expr}}_{\mathsf{t}}^\ast})}`. |
| |
| #. Let :math:`{{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast}` be :math:`{{{{\mathrm{evalexpr}}^\ast}^\ast}}{(z, {{{\mathit{expr}}_{\mathsf{e}}^\ast}^\ast})}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Let :math:`(s, f)` be the destructuring of :math:`z`. |
| |
| #. Let :math:`{\mathit{moduleinst}}` be :math:`{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})`. |
| |
| #. Let :math:`{F'}` be the :math:`\mathsf{frame}` :math:`\{ \mathsf{module}~{\mathit{moduleinst}} \}`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`{F'}`. |
| |
| #. Execute the sequence :math:`{{\mathit{instr}}_{\mathsf{e}}^\ast}`. |
| |
| #. Execute the sequence :math:`{{\mathit{instr}}_{\mathsf{d}}^\ast}`. |
| |
| #. If :math:`{{\mathit{start}}^?}` is defined, then: |
| |
| a. Let :math:`(\mathsf{start}~x)` be :math:`{{\mathit{start}}^?}`. |
| |
| #. Let :math:`{\mathit{instr}}_{\mathsf{s}}` be the instruction :math:`(\mathsf{call}~x)`. |
| |
| #. Execute the instruction :math:`{\mathit{instr}}_{\mathsf{s}}`. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Return :math:`{\mathit{moduleinst}}`. |
| |
| |
| :math:`{\mathrm{invoke}}(s, {\mathit{funcaddr}}, {{\mathit{val}}^\ast})` |
| ........................................................................ |
| |
| |
| 1. Assert: Due to validation, the :ref:`expansion <aux-expand-deftype>` of :math:`s{.}\mathsf{funcs}{}[{\mathit{funcaddr}}]{.}\mathsf{type}` is some :math:`\mathsf{func}~{\mathit{resulttype}} \rightarrow {\mathit{resulttype}}`. |
| |
| #. Let :math:`(\mathsf{func}~{t_1^\ast}~\rightarrow~{t_2^\ast})` be the destructuring of the :ref:`expansion <aux-expand-deftype>` of :math:`s{.}\mathsf{funcs}{}[{\mathit{funcaddr}}]{.}\mathsf{type}`. |
| |
| #. If :math:`{|{t_1^\ast}|} \neq {|{{\mathit{val}}^\ast}|}`, then: |
| |
| a. Fail. |
| |
| #. For all :math:`t_1` in :math:`{t_1^\ast}`, and corresponding :math:`{\mathit{val}}` in :math:`{{\mathit{val}}^\ast}`: |
| |
| a. If :math:`{\mathit{val}}` is not :ref:`valid <valid-val>` with type :math:`t_1`, then: |
| |
| 1) Fail. |
| |
| #. Let :math:`k` be the length of :math:`{t_2^\ast}`. |
| |
| #. Let :math:`F` be the :math:`\mathsf{frame}` :math:`\{ \mathsf{module}~\{ \} \}` whose arity is :math:`k`. |
| |
| #. Push the :math:`\mathsf{frame}` :math:`F`. |
| |
| #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack. |
| |
| #. Push the value :math:`(\mathsf{ref{.}func}~{\mathit{funcaddr}})` to the stack. |
| |
| #. Execute the instruction :math:`(\mathsf{call\_ref}~s{.}\mathsf{funcs}{}[{\mathit{funcaddr}}]{.}\mathsf{type})`. |
| |
| #. Pop the values :math:`{{\mathit{val}'}^{k}}` from the stack. |
| |
| #. Pop the :math:`\mathsf{frame}` from the stack. |
| |
| #. Return :math:`{{\mathit{val}'}^{k}}`. |
| |
| |
| :math:`{\bigoplus}\, {{\mathit{idctxt}}^\ast}` |
| .............................................. |
| |
| |
| 1. If :math:`{{\mathit{idctxt}}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\{ \}`. |
| |
| #. Let :math:`I~{{I'}^\ast}` be :math:`{{\mathit{idctxt}}^\ast}`. |
| |
| #. Return `I ++ $concat_idctxt(I'*{I' <- I'*})`. |
| |
| |
| :math:`{\mathrm{types}}({{\mathit{decl}'}^\ast})` |
| ................................................. |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{type}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{type}}~{\mathrm{types}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{imports}}({{\mathit{decl}'}^\ast})` |
| ................................................... |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{import}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{import}}~{\mathrm{imports}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{tags}}({{\mathit{decl}'}^\ast})` |
| ................................................ |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{tag}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{tag}}~{\mathrm{tags}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{globals}}({{\mathit{decl}'}^\ast})` |
| ................................................... |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{global}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{global}}~{\mathrm{globals}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{mems}}({{\mathit{decl}'}^\ast})` |
| ................................................ |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{mem}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{mem}}~{\mathrm{mems}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{tables}}({{\mathit{decl}'}^\ast})` |
| .................................................. |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{table}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{table}}~{\mathrm{tables}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{funcs}}({{\mathit{decl}'}^\ast})` |
| ................................................. |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{func}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{func}}~{\mathrm{funcs}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{datas}}({{\mathit{decl}'}^\ast})` |
| ................................................. |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{data}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{data}}~{\mathrm{datas}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{elems}}({{\mathit{decl}'}^\ast})` |
| ................................................. |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{elem}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{elem}}~{\mathrm{elems}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{starts}}({{\mathit{decl}'}^\ast})` |
| .................................................. |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{start}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{start}}~{\mathrm{starts}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{exports}}({{\mathit{decl}'}^\ast})` |
| ................................................... |
| |
| |
| 1. If :math:`{{\mathit{decl}'}^\ast} = \epsilon`, then: |
| |
| a. Return :math:`\epsilon`. |
| |
| #. Let :math:`{\mathit{export}}~{{\mathit{decl}'}^\ast}` be :math:`{{\mathit{decl}'}^\ast}`. |
| |
| #. Return :math:`{\mathit{export}}~{\mathrm{exports}}({{\mathit{decl}'}^\ast})`. |
| |
| |
| :math:`{\mathrm{ordered}}({{\mathit{decl}}^\ast})` |
| .................................................. |
| |
| |
| 1. If :math:`{\mathrm{imports}}({{\mathit{decl}}^\ast}) = \epsilon`, then: |
| |
| a. Return true. |
| |
| #. Assert: Due to validation, YetE: Nondeterministic assignment target: decl_1*{decl_1 <- decl_1*} :: [import] :: decl_2*{decl_2 <- decl_2*}. |
| |
| #. Let :math:`{{\mathit{decl}}_1^\ast}~{\mathit{import}}~{{\mathit{decl}}_2^\ast}` be :math:`{{\mathit{decl}}^\ast}`. |
| |
| #. Return :math:`{\mathrm{imports}}({{\mathit{decl}}_1^\ast}) = \epsilon` and :math:`{\mathrm{tags}}({{\mathit{decl}}_1^\ast}) = \epsilon` and :math:`{\mathrm{globals}}({{\mathit{decl}}_1^\ast}) = \epsilon` and :math:`{\mathrm{mems}}({{\mathit{decl}}_1^\ast}) = \epsilon` and :math:`{\mathrm{tables}}({{\mathit{decl}}_1^\ast}) = \epsilon` and :math:`{\mathrm{funcs}}({{\mathit{decl}}_1^\ast}) = \epsilon`. |
| |
| |
| NotImmutReachable(:math:`{\mathit{fv}}_1`, :math:`s`, :math:`{\mathit{fv}}_2`) |
| .............................................................................. |
| |
| |
| 1. If `rel(ImmutReachable, [fv_1, s, fv_2])`, then: |
| |
| a. Return false. |
| |
| #. Return true. |
| |
| |
| :math:`{{{\mathrm{allocX}}^\ast}}{(s, {{X''}^\ast}, {{Y''}^\ast})}` |
| ................................................................... |
| |
| |
| 1. If :math:`{{X''}^\ast} = \epsilon`, then: |
| |
| a. Assert: Due to validation, :math:`{{Y''}^\ast} = \epsilon`. |
| |
| #. Return :math:`\epsilon`. |
| |
| #. Else: |
| |
| a. Let :math:`X~{{X'}^\ast}` be :math:`{{X''}^\ast}`. |
| |
| #. Assert: Due to validation, :math:`{|{{Y''}^\ast}|} \geq 1`. |
| |
| #. Let :math:`Y~{{Y'}^\ast}` be :math:`{{Y''}^\ast}`. |
| |
| #. Let :math:`a` be :math:`{\mathrm{allocX}}(X, Y, s, X, Y)`. |
| |
| #. Let :math:`{{a'}^\ast}` be :math:`{{{\mathrm{allocX}}^\ast}}{(s, {{X'}^\ast}, {{Y'}^\ast})}`. |
| |
| #. Return :math:`a~{{a'}^\ast}`. |
| |
| |
| :math:`X` |
| ......... |
| |
| |
| 1. Return :math:`0`. |
| |
| |
| :math:`\mathsf{eval\_expr}~{{\mathit{instr}}^\ast}` |
| ................................................... |
| |
| |
| 1. Execute the sequence :math:`{{\mathit{instr}}^\ast}`. |
| |
| #. Pop the value :math:`{\mathit{val}}` from the stack. |
| |
| #. Return :math:`{\mathit{val}}`. |
| |
| |
| == Complete. |
| spectec 0.5 generator |
| == Parsing... |
| == Elaboration... |
| == IL Validation... |
| == Running pass sideconditions... |
| == IL Validation after pass sideconditions... |
| == Translating to AL... |
| == Prose Generation... |
| Expand |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is comptype if: |
| - the sub type $unrolldt(deftype) is (SUB final? typeuse* comptype). |
| |
| Expand_use |
| - The :ref:`expansion <aux-expand-typeuse>` of C is comptype if: |
| - Either: |
| - the type use typeuse is deftype. |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is comptype. |
| - Or: |
| - typeuse is (_IDX typeidx). |
| - the type C.TYPES[typeidx] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[typeidx] is comptype. |
| |
| Expand_use/deftype |
| - The :ref:`expansion <aux-expand-typeuse>` of C is comptype if: |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is comptype. |
| |
| Expand_use/typeidx |
| - The :ref:`expansion <aux-expand-typeuse>` of C is comptype if: |
| - the type C.TYPES[typeidx] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[typeidx] is comptype. |
| |
| NotImmutReachable |
| - fv_2 is not immutably reachable from fv_1. |
| |
| Numtype_ok |
| - the number type numtype is always valid. |
| |
| Vectype_ok |
| - the vector type vectype is always valid. |
| |
| Packtype_ok |
| - the packed type packtype is always valid. |
| |
| Packtype_sub |
| - packtype matches only itself. |
| |
| Numtype_sub |
| - numtype matches only itself. |
| |
| Vectype_sub |
| - vectype matches only itself. |
| |
| Heaptype_ok |
| - the heap type heaptype is valid if: |
| - Either: |
| - heaptype is absheaptype. |
| - Or: |
| - heaptype is typeuse. |
| - the type use typeuse is valid. |
| - Or: |
| - heaptype is BOT. |
| |
| Heaptype_ok/abs |
| - the heap type absheaptype is always valid. |
| |
| Heaptype_ok/typeuse |
| - the heap type typeuse is valid if: |
| - typeuse is valid. |
| |
| Heaptype_ok/bot |
| - the heap type BOT is always valid. |
| |
| Reftype_ok |
| - the reference type (REF NULL? heaptype) is valid if: |
| - the heap type heaptype is valid. |
| |
| Valtype_ok |
| - the value type valtype is valid if: |
| - Either: |
| - valtype is numtype. |
| - the number type numtype is valid. |
| - Or: |
| - valtype is vectype. |
| - the vector type vectype is valid. |
| - Or: |
| - valtype is reftype. |
| - the reference type reftype is valid. |
| - Or: |
| - valtype is BOT. |
| |
| Valtype_ok/num |
| - the value type numtype is valid if: |
| - numtype is valid. |
| |
| Valtype_ok/vec |
| - the value type vectype is valid if: |
| - vectype is valid. |
| |
| Valtype_ok/ref |
| - the value type reftype is valid if: |
| - reftype is valid. |
| |
| Valtype_ok/bot |
| - the value type BOT is always valid. |
| |
| Typeuse_ok |
| - the type use typeuse is valid if: |
| - Either: |
| - typeuse is (_IDX typeidx). |
| - the type C.TYPES[typeidx] exists. |
| - Or: |
| - typeuse is (REC i). |
| - the recursive type C.RECS[i] exists. |
| - Or: |
| - typeuse is deftype. |
| - the defined type deftype is valid. |
| |
| Typeuse_ok/typeidx |
| - the type use (_IDX typeidx) is valid if: |
| - the type C.TYPES[typeidx] exists. |
| |
| Typeuse_ok/rec |
| - the type use (REC i) is valid if: |
| - the recursive type C.RECS[i] exists. |
| |
| Typeuse_ok/deftype |
| - the type use deftype is valid if: |
| - deftype is valid. |
| |
| Resulttype_ok |
| - the result type t* is valid if: |
| - For all t in t*: |
| - the value type t is valid. |
| |
| Fieldtype_ok |
| - the field type (MUT? storagetype) is valid if: |
| - the storage type storagetype is valid. |
| |
| Storagetype_ok |
| - the storage type storagetype is valid if: |
| - Either: |
| - storagetype is valtype. |
| - the value type valtype is valid. |
| - Or: |
| - storagetype is packtype. |
| - the packed type packtype is valid. |
| |
| Storagetype_ok/val |
| - the storage type valtype is valid if: |
| - valtype is valid. |
| |
| Storagetype_ok/pack |
| - the storage type packtype is valid if: |
| - packtype is valid. |
| |
| Comptype_ok |
| - the composite type comptype is valid if: |
| - Either: |
| - comptype is (STRUCT fieldtype*). |
| - For all fieldtype in fieldtype*: |
| - the field type fieldtype is valid. |
| - Or: |
| - comptype is (ARRAY fieldtype). |
| - fieldtype is valid. |
| - Or: |
| - comptype is (FUNC t_1* -> t_2*). |
| - the result type t_1* is valid. |
| - the result type t_2* is valid. |
| |
| Comptype_ok/struct |
| - the composite type (STRUCT fieldtype*) is valid if: |
| - For all fieldtype in fieldtype*: |
| - the field type fieldtype is valid. |
| |
| Comptype_ok/array |
| - the composite type (ARRAY fieldtype) is valid if: |
| - the field type fieldtype is valid. |
| |
| Comptype_ok/func |
| - the composite type (FUNC t_1* -> t_2*) is valid if: |
| - the result type t_1* is valid. |
| - the result type t_2* is valid. |
| |
| Subtype_ok2 |
| - the sub type (SUB FINAL? typeuse* comptype) is valid for (OK i) if: |
| - |typeuse*| is less than or equal to 1. |
| - For all typeuse in typeuse*: |
| - the type use typeuse is valid. |
| - $before(typeuse, i) is true. |
| - the sub type $unrollht_(C, typeuse) is (SUB ?() typeuse'* comptype'). |
| - comptype'* is the concatenation of all such comptype'. |
| - the composite type comptype is valid. |
| - For all comptype' in comptype'*: |
| - comptype matches the composite type comptype'. |
| |
| Rectype_ok2 |
| - the recursive type (REC subtype*) is valid for (OK i) if: |
| - Either: |
| - the sub type sequence subtype* is []. |
| - Or: |
| - subtype* is [subtype_1] :: subtype'*. |
| - the sub type subtype_1 is valid for (OK i). |
| - the recursive type (REC subtype'*) is valid for (OK (i + 1)). |
| |
| Rectype_ok2/empty |
| - the recursive type (REC []) is valid for (OK i). |
| |
| Rectype_ok2/cons |
| - the recursive type (REC [subtype_1] :: subtype*) is valid for (OK i) if: |
| - the sub type subtype_1 is valid for (OK i). |
| - the recursive type (REC subtype*) is valid for (OK (i + 1)). |
| |
| Deftype_ok |
| - the defined type (_DEF rectype i) is valid if: |
| - the context C' is the context C with .RECS prepended by subtype^n. |
| - Under the context C', the recursive type rectype is valid for (OK 0). |
| - rectype is (REC subtype^n). |
| - i is less than n. |
| |
| Comptype_sub |
| - the composite type comptype_1 matches the composite type comptype_2 if: |
| - Either: |
| - comptype_1 is (STRUCT ft_1* :: ft'_1*). |
| - comptype_2 is (STRUCT ft_2*). |
| - For all ft_1 in ft_1*, and corresponding ft_2 in ft_2*: |
| - the field type ft_1 matches the field type ft_2. |
| - Or: |
| - comptype_1 is (ARRAY ft_1). |
| - comptype_2 is (ARRAY ft_2). |
| - ft_1 matches ft_2. |
| - Or: |
| - comptype_1 is (FUNC t_11* -> t_12*). |
| - comptype_2 is (FUNC t_21* -> t_22*). |
| - the result type t_21* matches the result type t_11*. |
| - the result type t_12* matches the result type t_22*. |
| |
| Comptype_sub/struct |
| - the composite type (STRUCT ft_1* :: ft'_1*) matches the composite type (STRUCT ft_2*) if: |
| - For all ft_1 in ft_1*, and corresponding ft_2 in ft_2*: |
| - the field type ft_1 matches the field type ft_2. |
| |
| Comptype_sub/array |
| - the composite type (ARRAY ft_1) matches the composite type (ARRAY ft_2) if: |
| - the field type ft_1 matches the field type ft_2. |
| |
| Comptype_sub/func |
| - the composite type (FUNC t_11* -> t_12*) matches the composite type (FUNC t_21* -> t_22*) if: |
| - the result type t_21* matches the result type t_11*. |
| - the result type t_12* matches the result type t_22*. |
| |
| Deftype_sub |
| - the defined type deftype_1 matches the defined type deftype_2 if: |
| - Either: |
| - the defined type $clos_deftype(C, deftype_1) is $clos_deftype(C, deftype_2). |
| - Or: |
| - the sub type $unrolldt(deftype_1) is (SUB final? typeuse* ct). |
| - |typeuse*| is greater than i. |
| - the type use typeuse*[i] matches deftype_2. |
| |
| Deftype_sub/refl |
| - the defined type deftype_1 matches the defined type deftype_2 if: |
| - the defined type $clos_deftype(C, deftype_1) is $clos_deftype(C, deftype_2). |
| |
| Deftype_sub/super |
| - the defined type deftype_1 matches the defined type deftype_2 if: |
| - the sub type $unrolldt(deftype_1) is (SUB final? typeuse* ct). |
| - |typeuse*| is greater than i. |
| - the type use typeuse*[i] matches deftype_2. |
| |
| Heaptype_sub |
| - the heap type heaptype_1 matches the heap type heaptype_2 if: |
| - Either: |
| - heaptype_2 is heaptype_1. |
| - Or: |
| - the heap type heaptype' is valid. |
| - heaptype_1 matches heaptype'. |
| - heaptype' matches heaptype_2. |
| - Or: |
| - heaptype_1 is EQ. |
| - heaptype_2 is ANY. |
| - Or: |
| - heaptype_1 is I31. |
| - heaptype_2 is EQ. |
| - Or: |
| - heaptype_1 is STRUCT. |
| - heaptype_2 is EQ. |
| - Or: |
| - heaptype_1 is ARRAY. |
| - heaptype_2 is EQ. |
| - Or: |
| - heaptype_1 is deftype. |
| - heaptype_2 is STRUCT. |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is (STRUCT fieldtype*). |
| - Or: |
| - heaptype_1 is deftype. |
| - heaptype_2 is ARRAY. |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is (ARRAY fieldtype). |
| - Or: |
| - heaptype_1 is deftype. |
| - heaptype_2 is FUNC. |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is (FUNC t_1* -> t_2*). |
| - Or: |
| - heaptype_1 is deftype_1. |
| - heaptype_2 is deftype_2. |
| - the defined type deftype_1 matches the defined type deftype_2. |
| - Or: |
| - heaptype_1 is (_IDX typeidx). |
| - the type C.TYPES[typeidx] exists. |
| - C.TYPES[typeidx] matches heaptype_2. |
| - Or: |
| - heaptype_2 is (_IDX typeidx). |
| - C.TYPES[typeidx] exists. |
| - heaptype_1 matches C.TYPES[typeidx]. |
| - Or: |
| - heaptype_1 is (REC i). |
| - heaptype_2 is STRUCT. |
| - the recursive type C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? [] (STRUCT fieldtype*)). |
| - Or: |
| - heaptype_1 is (REC i). |
| - heaptype_2 is ARRAY. |
| - C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? [] (ARRAY fieldtype)). |
| - Or: |
| - heaptype_1 is (REC i). |
| - heaptype_2 is FUNC. |
| - C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? [] (FUNC t_1* -> t_2*)). |
| - Or: |
| - heaptype_1 is (REC i). |
| - |typeuse*| is greater than j. |
| - heaptype_2 is typeuse*[j]. |
| - C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? typeuse* ct). |
| - Or: |
| - heaptype_1 is NONE. |
| - heaptype_2 matches the heap type ANY. |
| - heaptype_2 is not BOT. |
| - Or: |
| - heaptype_1 is NOFUNC. |
| - heaptype_2 matches the heap type FUNC. |
| - heaptype_2 is not BOT. |
| - Or: |
| - heaptype_1 is NOEXN. |
| - heaptype_2 matches the heap type EXN. |
| - heaptype_2 is not BOT. |
| - Or: |
| - heaptype_1 is NOEXTERN. |
| - heaptype_2 matches the heap type EXTERN. |
| - heaptype_2 is not BOT. |
| - Or: |
| - heaptype_1 is BOT. |
| |
| Heaptype_sub/refl |
| - the heap type heaptype matches only itself. |
| |
| Heaptype_sub/trans |
| - the heap type heaptype_1 matches the heap type heaptype_2 if: |
| - the heap type heaptype' is valid. |
| - heaptype_1 matches heaptype'. |
| - heaptype' matches heaptype_2. |
| |
| Heaptype_sub/eq |
| - the heap type EQ matches the heap type ANY. |
| |
| Heaptype_sub/i31 |
| - the heap type I31 matches EQ. |
| |
| Heaptype_sub/struct |
| - the heap type STRUCT matches EQ. |
| |
| Heaptype_sub/array |
| - the heap type ARRAY matches EQ. |
| |
| Heaptype_sub/struct |
| - the heap type deftype matches the heap type STRUCT if: |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is (STRUCT fieldtype*). |
| |
| Heaptype_sub/array |
| - the heap type deftype matches the heap type ARRAY if: |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is (ARRAY fieldtype). |
| |
| Heaptype_sub/func |
| - the heap type deftype matches the heap type FUNC if: |
| - The :ref:`expansion <aux-expand-deftype>` of deftype is (FUNC t_1* -> t_2*). |
| |
| Heaptype_sub/def |
| - the heap type deftype_1 matches the heap type deftype_2 if: |
| - deftype_1 matches deftype_2. |
| |
| Heaptype_sub/typeidx |
| - the heap type (_IDX typeidx) matches the heap type heaptype if: |
| - the type C.TYPES[typeidx] exists. |
| - C.TYPES[typeidx] matches heaptype. |
| |
| Heaptype_sub/typeidx |
| - the heap type heaptype matches the heap type (_IDX typeidx) if: |
| - the type C.TYPES[typeidx] exists. |
| - heaptype matches C.TYPES[typeidx]. |
| |
| Heaptype_sub/rec |
| - the heap type (REC i) matches the heap type STRUCT if: |
| - the recursive type C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? [] (STRUCT fieldtype*)). |
| |
| Heaptype_sub/rec |
| - the heap type (REC i) matches the heap type ARRAY if: |
| - the recursive type C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? [] (ARRAY fieldtype)). |
| |
| Heaptype_sub/rec |
| - the heap type (REC i) matches the heap type FUNC if: |
| - the recursive type C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? [] (FUNC t_1* -> t_2*)). |
| |
| Heaptype_sub/rec |
| - the heap type (REC i) matches the type use typeuse*[j] if: |
| - |typeuse*| is greater than j. |
| - the recursive type C.RECS[i] exists. |
| - C.RECS[i] is (SUB final? typeuse* ct). |
| |
| Heaptype_sub/none |
| - the heap type NONE matches the heap type heaptype if: |
| - heaptype matches the heap type ANY. |
| - heaptype is not BOT. |
| |
| Heaptype_sub/nofunc |
| - the heap type NOFUNC matches the heap type heaptype if: |
| - heaptype matches the heap type FUNC. |
| - heaptype is not BOT. |
| |
| Heaptype_sub/noexn |
| - the heap type NOEXN matches the heap type heaptype if: |
| - heaptype matches the heap type EXN. |
| - heaptype is not BOT. |
| |
| Heaptype_sub/noextern |
| - the heap type NOEXTERN matches the heap type heaptype if: |
| - heaptype matches the heap type EXTERN. |
| - heaptype is not BOT. |
| |
| Heaptype_sub/bot |
| - the heap type BOT matches heaptype. |
| |
| Reftype_sub |
| - the reference type (REF null_1? ht_1) matches the reference type (REF null_2? ht_2) if: |
| - the heap type ht_1 matches the heap type ht_2. |
| - Either: |
| - null_1? is ?(). |
| - null_2? is ?(). |
| - Or: |
| - null_1? is NULL?. |
| - null_2? is ?(NULL). |
| |
| Reftype_sub/nonnull |
| - the reference type (REF ?() ht_1) matches the reference type (REF ?() ht_2) if: |
| - the heap type ht_1 matches the heap type ht_2. |
| |
| Reftype_sub/null |
| - the reference type (REF NULL? ht_1) matches the reference type (REF ?(NULL) ht_2) if: |
| - the heap type ht_1 matches the heap type ht_2. |
| |
| Valtype_sub |
| - the value type valtype_1 matches the value type valtype_2 if: |
| - Either: |
| - valtype_1 is numtype_1. |
| - valtype_2 is numtype_2. |
| - the number type numtype_1 matches the number type numtype_2. |
| - Or: |
| - valtype_1 is vectype_1. |
| - valtype_2 is vectype_2. |
| - the vector type vectype_1 matches the vector type vectype_2. |
| - Or: |
| - valtype_1 is reftype_1. |
| - valtype_2 is reftype_2. |
| - the reference type reftype_1 matches the reference type reftype_2. |
| - Or: |
| - valtype_1 is BOT. |
| |
| Valtype_sub/num |
| - the value type numtype_1 matches the value type numtype_2 if: |
| - numtype_1 matches numtype_2. |
| |
| Valtype_sub/vec |
| - the value type vectype_1 matches the value type vectype_2 if: |
| - vectype_1 matches vectype_2. |
| |
| Valtype_sub/ref |
| - the value type reftype_1 matches the value type reftype_2 if: |
| - reftype_1 matches reftype_2. |
| |
| Valtype_sub/bot |
| - the value type BOT matches the value type valtype. |
| |
| Resulttype_sub |
| - the result type t_1* matches the result type t_2* if: |
| - For all t_1 in t_1*, and corresponding t_2 in t_2*: |
| - the value type t_1 matches the value type t_2. |
| |
| Storagetype_sub |
| - the storage type storagetype_1 matches the storage type storagetype_2 if: |
| - Either: |
| - storagetype_1 is valtype_1. |
| - storagetype_2 is valtype_2. |
| - the value type valtype_1 matches the value type valtype_2. |
| - Or: |
| - storagetype_1 is packtype_1. |
| - storagetype_2 is packtype_2. |
| - the packed type packtype_1 matches the packed type packtype_2. |
| |
| Storagetype_sub/val |
| - the storage type valtype_1 matches the storage type valtype_2 if: |
| - valtype_1 matches valtype_2. |
| |
| Storagetype_sub/pack |
| - the storage type packtype_1 matches the storage type packtype_2 if: |
| - packtype_1 matches packtype_2. |
| |
| Fieldtype_sub |
| - the field type (mut_1? zt_1) matches the field type (mut_2? zt_2) if: |
| - the storage type zt_1 matches the storage type zt_2. |
| - Either: |
| - mut_1? is ?(). |
| - mut_2? is ?(). |
| - Or: |
| - mut_1? is ?(MUT). |
| - mut_2? is ?(MUT). |
| - zt_2 matches zt_1. |
| |
| Fieldtype_sub/const |
| - the field type (?() zt_1) matches the field type (?() zt_2) if: |
| - the storage type zt_1 matches the storage type zt_2. |
| |
| Fieldtype_sub/var |
| - the field type (?(MUT) zt_1) matches the field type (?(MUT) zt_2) if: |
| - the storage type zt_1 matches the storage type zt_2. |
| - zt_2 matches zt_1. |
| |
| Localtype_ok |
| - the local type (init t) is valid if: |
| - the value type t is valid. |
| |
| Instrtype_ok |
| - the instruction type t_1* ->_ x* t_2* is valid if: |
| - the result type t_1* is valid. |
| - the result type t_2* is valid. |
| - For all x in x*: |
| - the local C.LOCALS[x] exists. |
| |
| Subtype_ok |
| - the sub type (SUB FINAL? (_IDX x)* comptype) is valid for the type index (OK x_0) if: |
| - |x*| is less than or equal to 1. |
| - For all x in x*: |
| - the index x is less than x_0. |
| - the type C.TYPES[x] exists. |
| - the sub type $unrolldt(C.TYPES[x]) is (SUB ?() yy* comptype'). |
| - comptype'* is the concatenation of all such comptype'. |
| - the composite type comptype is valid. |
| - For all comptype' in comptype'*: |
| - comptype matches the composite type comptype'. |
| |
| Rectype_ok |
| - the recursive type (REC subtype*) is valid for the type index (OK x) if: |
| - Either: |
| - the sub type sequence subtype* is []. |
| - Or: |
| - subtype* is [subtype_1] :: subtype'*. |
| - the sub type subtype_1 is valid for (OK x). |
| - the recursive type (REC subtype'*) is valid for the type index (OK (x + 1)). |
| |
| Rectype_ok/empty |
| - the recursive type (REC []) is valid for (OK x). |
| |
| Rectype_ok/cons |
| - the recursive type (REC [subtype_1] :: subtype*) is valid for the type index (OK x) if: |
| - the sub type subtype_1 is valid for (OK x). |
| - the recursive type (REC subtype*) is valid for the type index (OK (x + 1)). |
| |
| Limits_ok |
| - the limits range ([ n .. m? ]) is valid within k if: |
| - n is less than or equal to k. |
| - If m is defined, then: |
| - n is less than or equal to m. |
| - m is less than or equal to k. |
| |
| Tagtype_ok |
| - the tag type typeuse is valid if: |
| - typeuse is valid. |
| - The :ref:`expansion <aux-expand-typeuse>` of C is (FUNC t_1* -> t_2*). |
| |
| Globaltype_ok |
| - the global type (MUT? t) is valid if: |
| - the value type t is valid. |
| |
| Memtype_ok |
| - the memory type addrtype limits PAGE is valid if: |
| - the limits range limits is valid within (2 ^ ($size(addrtype) - 16)). |
| |
| Tabletype_ok |
| - the table type (addrtype limits reftype) is valid if: |
| - the limits range limits is valid within ((2 ^ $size(addrtype)) - 1). |
| - the reference type reftype is valid. |
| |
| Externtype_ok |
| - the external type externtype is valid if: |
| - Either: |
| - externtype is (TAG tagtype). |
| - the tag type tagtype is valid. |
| - Or: |
| - externtype is (GLOBAL globaltype). |
| - the global type globaltype is valid. |
| - Or: |
| - externtype is (MEM memtype). |
| - the memory type memtype is valid. |
| - Or: |
| - externtype is (TABLE tabletype). |
| - the table type tabletype is valid. |
| - Or: |
| - externtype is (FUNC typeuse). |
| - the type use typeuse is valid. |
| - The :ref:`expansion <aux-expand-typeuse>` of C is (FUNC t_1* -> t_2*). |
| |
| Externtype_ok/tag |
| - the external type (TAG tagtype) is valid if: |
| - the tag type tagtype is valid. |
| |
| Externtype_ok/global |
| - the external type (GLOBAL globaltype) is valid if: |
| - the global type globaltype is valid. |
| |
| Externtype_ok/mem |
| - the external type (MEM memtype) is valid if: |
| - the memory type memtype is valid. |
| |
| Externtype_ok/table |
| - the external type (TABLE tabletype) is valid if: |
| - the table type tabletype is valid. |
| |
| Externtype_ok/func |
| - the external type (FUNC typeuse) is valid if: |
| - the type use typeuse is valid. |
| - The :ref:`expansion <aux-expand-typeuse>` of C is (FUNC t_1* -> t_2*). |
| |
| Instrtype_sub |
| - the instruction type t_11* ->_ x_1* t_12* matches the instruction type t_21* ->_ x_2* t_22* if: |
| - the result type t_21* matches the result type t_11*. |
| - the result type t_12* matches the result type t_22*. |
| - the local index sequence x* is $setminus_(`localidx, x_2*, x_1*). |
| - For all x in x*: |
| - the local C.LOCALS[x] exists. |
| - C.LOCALS[x] is (SET t). |
| |
| Limits_sub |
| - the limits range ([ n_1 .. u64_1? ]) matches the limits range ([ n_2 .. u64_2? ]) if: |
| - n_1 is greater than or equal to n_2. |
| - Either: |
| - u64_1? is ?(m_1). |
| - If u64_2 is defined, then: |
| - m_1 is less than or equal to u64_2. |
| - Or: |
| - u64_1? is ?(). |
| - u64_2? is ?(). |
| |
| Limits_sub/max |
| - the limits range ([ n_1 .. ?(m_1) ]) matches the limits range ([ n_2 .. m_2? ]) if: |
| - n_1 is greater than or equal to n_2. |
| - If m_2 is defined, then: |
| - m_1 is less than or equal to m_2. |
| |
| Limits_sub/eps |
| - the limits range ([ n_1 .. ?() ]) matches the limits range ([ n_2 .. ?() ]) if: |
| - n_1 is greater than or equal to n_2. |
| |
| Tagtype_sub |
| - the tag type deftype_1 matches the tag type deftype_2 if: |
| - deftype_1 matches deftype_2. |
| - deftype_2 matches deftype_1. |
| |
| Globaltype_sub |
| - the global type (mut_1? valtype_1) matches the global type (mut_2? valtype_2) if: |
| - the value type valtype_1 matches the value type valtype_2. |
| - Either: |
| - mut_1? is ?(). |
| - mut_2? is ?(). |
| - Or: |
| - mut_1? is ?(MUT). |
| - mut_2? is ?(MUT). |
| - valtype_2 matches valtype_1. |
| |
| Globaltype_sub/const |
| - the global type (?() valtype_1) matches the global type (?() valtype_2) if: |
| - the value type valtype_1 matches the value type valtype_2. |
| |
| Globaltype_sub/var |
| - the global type (?(MUT) valtype_1) matches the global type (?(MUT) valtype_2) if: |
| - the value type valtype_1 matches the value type valtype_2. |
| - valtype_2 matches valtype_1. |
| |
| Memtype_sub |
| - the memory type addrtype limits_1 PAGE matches the memory type addrtype limits_2 PAGE if: |
| - the limits range limits_1 matches the limits range limits_2. |
| |
| Tabletype_sub |
| - the table type (addrtype limits_1 reftype_1) matches the table type (addrtype limits_2 reftype_2) if: |
| - the limits range limits_1 matches the limits range limits_2. |
| - the reference type reftype_1 matches the reference type reftype_2. |
| - reftype_2 matches reftype_1. |
| |
| Externtype_sub |
| - the external type externtype_1 matches the external type externtype_2 if: |
| - Either: |
| - externtype_1 is (TAG tagtype_1). |
| - externtype_2 is (TAG tagtype_2). |
| - the tag type tagtype_1 matches the tag type tagtype_2. |
| - Or: |
| - externtype_1 is (GLOBAL globaltype_1). |
| - externtype_2 is (GLOBAL globaltype_2). |
| - the global type globaltype_1 matches the global type globaltype_2. |
| - Or: |
| - externtype_1 is (MEM memtype_1). |
| - externtype_2 is (MEM memtype_2). |
| - the memory type memtype_1 matches the memory type memtype_2. |
| - Or: |
| - externtype_1 is (TABLE tabletype_1). |
| - externtype_2 is (TABLE tabletype_2). |
| - the table type tabletype_1 matches the table type tabletype_2. |
| - Or: |
| - externtype_1 is (FUNC deftype_1). |
| - externtype_2 is (FUNC deftype_2). |
| - the defined type deftype_1 matches the defined type deftype_2. |
| |
| Externtype_sub/tag |
| - the external type (TAG tagtype_1) matches the external type (TAG tagtype_2) if: |
| - the tag type tagtype_1 matches the tag type tagtype_2. |
| |
| Externtype_sub/global |
| - the external type (GLOBAL globaltype_1) matches the external type (GLOBAL globaltype_2) if: |
| - the global type globaltype_1 matches the global type globaltype_2. |
| |
| Externtype_sub/mem |
| - the external type (MEM memtype_1) matches the external type (MEM memtype_2) if: |
| - the memory type memtype_1 matches the memory type memtype_2. |
| |
| Externtype_sub/table |
| - the external type (TABLE tabletype_1) matches the external type (TABLE tabletype_2) if: |
| - the table type tabletype_1 matches the table type tabletype_2. |
| |
| Externtype_sub/func |
| - the external type (FUNC deftype_1) matches the external type (FUNC deftype_2) if: |
| - the defined type deftype_1 matches the defined type deftype_2. |
| |
| Blocktype_ok |
| - the block type blocktype is valid as the instruction type valtype* -> valtype'* if: |
| - Either: |
| - blocktype is (_RESULT valtype''?). |
| - the value type sequence valtype* is []. |
| - the value type sequence valtype'* is valtype''?. |
| - If valtype'' is defined, then: |
| - the value type valtype'' is valid. |
| - Or: |
| - blocktype is (_IDX typeidx). |
| - the type C.TYPES[typeidx] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[typeidx] is (FUNC valtype* -> valtype'*). |
| |
| Blocktype_ok/valtype |
| - the block type (_RESULT valtype?) is valid as the instruction type [] -> valtype? if: |
| - If valtype is defined, then: |
| - the value type valtype is valid. |
| |
| Blocktype_ok/typeidx |
| - the block type (_IDX typeidx) is valid as the instruction type t_1* -> t_2* if: |
| - the type C.TYPES[typeidx] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[typeidx] is (FUNC t_1* -> t_2*). |
| |
| Catch_ok |
| - the catch clause catch is valid if: |
| - the label C.LABELS[l] exists. |
| - Either: |
| - catch is (CATCH x l). |
| - the tag C.TAGS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of $as_deftype(C.TAGS[x]) is (FUNC t* -> []). |
| - the result type t* matches C.LABELS[l]. |
| - Or: |
| - catch is (CATCH_REF x l). |
| - C.TAGS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of $as_deftype(C.TAGS[x]) is (FUNC t* -> []). |
| - the result type t* :: [(REF ?() EXN)] matches C.LABELS[l]. |
| - Or: |
| - catch is (CATCH_ALL l). |
| - the result type [] matches C.LABELS[l]. |
| - Or: |
| - catch is (CATCH_ALL_REF l). |
| - the result type [(REF ?() EXN)] matches C.LABELS[l]. |
| |
| Catch_ok/catch |
| - the catch clause (CATCH x l) is valid if: |
| - the tag C.TAGS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of $as_deftype(C.TAGS[x]) is (FUNC t* -> []). |
| - the label C.LABELS[l] exists. |
| - the result type t* matches C.LABELS[l]. |
| |
| Catch_ok/catch_ref |
| - the catch clause (CATCH_REF x l) is valid if: |
| - the tag C.TAGS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of $as_deftype(C.TAGS[x]) is (FUNC t* -> []). |
| - the label C.LABELS[l] exists. |
| - the result type t* :: [(REF ?() EXN)] matches C.LABELS[l]. |
| |
| Catch_ok/catch_all |
| - the catch clause (CATCH_ALL l) is valid if: |
| - the label C.LABELS[l] exists. |
| - the result type [] matches C.LABELS[l]. |
| |
| Catch_ok/catch_all_ref |
| - the catch clause (CATCH_ALL_REF l) is valid if: |
| - the label C.LABELS[l] exists. |
| - the result type [(REF ?() EXN)] matches C.LABELS[l]. |
| |
| Defaultable |
| - the value type t is defaultable if: |
| - the value $default_(t) is not ?(). |
| |
| Memarg_ok |
| - { ALIGN: n; OFFSET: m } is valid for at and N if: |
| - (2 ^ n) is less than or equal to (N / 8). |
| - m is less than (2 ^ $size(at)). |
| |
| Instr_ok/nop |
| - the instruction NOP is valid with the instruction type [] -> []. |
| |
| Instr_ok/unreachable |
| - the instruction UNREACHABLE is valid with the instruction type t_1* -> t_2* if: |
| - t_1* -> t_2* is valid. |
| |
| Instr_ok/drop |
| - the instruction DROP is valid with the instruction type [t] -> [] if: |
| - the value type t is valid. |
| |
| Instr_ok/select |
| - the instruction (SELECT valtype?) is valid with the instruction type [t, t, I32] -> [t] if: |
| - the value type t is valid. |
| - Either: |
| - the value type sequence valtype? is ?([t]). |
| - Or: |
| - valtype? is ?(). |
| - t matches the value type t'. |
| - t' is numtype or t' is vectype. |
| |
| Instr_ok/block |
| - the instruction (BLOCK bt instr*) is valid with the instruction type t_1* -> t_2* if: |
| - the block type bt is valid as t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_2*]. |
| - Under the context C', the instruction sequence instr* is valid with the instruction type t_1* ->_ x* t_2*. |
| |
| Instr_ok/loop |
| - the instruction (LOOP bt instr*) is valid with the instruction type t_1* -> t_2* if: |
| - the block type bt is valid as t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_1*]. |
| - Under the context C', the instruction sequence instr* is valid with the instruction type t_1* ->_ x* t_2*. |
| |
| Instr_ok/if |
| - the instruction (IF bt instr_1* ELSE instr_2*) is valid with the instruction type t_1* :: [I32] -> t_2* if: |
| - the block type bt is valid as the instruction type t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_2*]. |
| - Under the context C', the instruction sequence instr_1* is valid with the instruction type t_1* ->_ x_1* t_2*. |
| - Under the context C', the instruction sequence instr_2* is valid with the instruction type t_1* ->_ x_2* t_2*. |
| |
| Instr_ok/br |
| - the instruction (BR l) is valid with the instruction type t_1* :: t* -> t_2* if: |
| - the label C.LABELS[l] exists. |
| - C.LABELS[l] is t*. |
| - the instruction type t_1* -> t_2* is valid. |
| |
| Instr_ok/br_if |
| - the instruction (BR_IF l) is valid with the instruction type t* :: [I32] -> t* if: |
| - the label C.LABELS[l] exists. |
| - C.LABELS[l] is t*. |
| |
| Instr_ok/br_table |
| - the instruction (BR_TABLE l* l') is valid with the instruction type t_1* :: t* :: [I32] -> t_2* if: |
| - For all l in l*: |
| - the label C.LABELS[l] exists. |
| - the result type t* matches C.LABELS[l]. |
| - the label C.LABELS[l'] exists. |
| - t* matches C.LABELS[l']. |
| - t_1* :: t* :: [I32] -> t_2* is valid. |
| |
| Instr_ok/br_on_null |
| - the instruction (BR_ON_NULL l) is valid with the instruction type t* :: [(REF ?(NULL) ht)] -> t* :: [(REF ?() ht)] if: |
| - the label C.LABELS[l] exists. |
| - C.LABELS[l] is t*. |
| - the heap type ht is valid. |
| |
| Instr_ok/br_on_non_null |
| - the instruction (BR_ON_NON_NULL l) is valid with the instruction type t* :: [(REF ?(NULL) ht)] -> t* if: |
| - the label C.LABELS[l] exists. |
| - C.LABELS[l] is t* :: [(REF NULL? ht)]. |
| |
| Instr_ok/br_on_cast |
| - the instruction (BR_ON_CAST l rt_1 rt_2) is valid with the instruction type t* :: [rt_1] -> t* :: [reftype] if: |
| - the label C.LABELS[l] exists. |
| - C.LABELS[l] is t* :: [rt]. |
| - the reference type rt_1 is valid. |
| - the reference type rt_2 is valid. |
| - rt_2 matches rt_1. |
| - rt_2 matches the reference type rt. |
| - the reference type reftype is $diffrt(rt_1, rt_2). |
| |
| Instr_ok/br_on_cast_fail |
| - the instruction (BR_ON_CAST_FAIL l rt_1 rt_2) is valid with the instruction type t* :: [rt_1] -> t* :: [rt_2] if: |
| - the label C.LABELS[l] exists. |
| - C.LABELS[l] is t* :: [rt]. |
| - the reference type rt_1 is valid. |
| - the reference type rt_2 is valid. |
| - rt_2 matches rt_1. |
| - the reference type $diffrt(rt_1, rt_2) matches the reference type rt. |
| |
| Instr_ok/call |
| - the instruction (CALL x) is valid with the instruction type t_1* -> t_2* if: |
| - the function C.FUNCS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.FUNCS[x] is (FUNC t_1* -> t_2*). |
| |
| Instr_ok/call_ref |
| - the instruction (CALL_REF (_IDX x)) is valid with the instruction type t_1* :: [(REF ?(NULL) (_IDX x))] -> t_2* if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (FUNC t_1* -> t_2*). |
| |
| Instr_ok/call_indirect |
| - the instruction (CALL_INDIRECT x (_IDX y)) is valid with the instruction type t_1* :: [at] -> t_2* if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt). |
| - the reference type rt matches the reference type (REF ?(NULL) FUNC). |
| - the type C.TYPES[y] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[y] is (FUNC t_1* -> t_2*). |
| |
| Instr_ok/return |
| - the instruction RETURN is valid with the instruction type t_1* :: t* -> t_2* if: |
| - the result type C.RETURN is ?(t*). |
| - the instruction type t_1* -> t_2* is valid. |
| |
| Instr_ok/return_call |
| - the instruction (RETURN_CALL x) is valid with the instruction type t_3* :: t_1* -> t_4* if: |
| - the function C.FUNCS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.FUNCS[x] is (FUNC t_1* -> t_2*). |
| - the result type C.RETURN is ?(t'_2*). |
| - the result type t_2* matches the result type t'_2*. |
| - the instruction type t_3* -> t_4* is valid. |
| |
| Instr_ok/return_call_ref |
| - the instruction (RETURN_CALL_REF (_IDX x)) is valid with the instruction type t_3* :: t_1* :: [(REF ?(NULL) (_IDX x))] -> t_4* if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (FUNC t_1* -> t_2*). |
| - the result type C.RETURN is ?(t'_2*). |
| - the result type t_2* matches the result type t'_2*. |
| - the instruction type t_3* -> t_4* is valid. |
| |
| Instr_ok/return_call_indirect |
| - the instruction (RETURN_CALL_INDIRECT x (_IDX y)) is valid with the instruction type t_3* :: t_1* :: [at] -> t_4* if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt). |
| - the reference type rt matches the reference type (REF ?(NULL) FUNC). |
| - the type C.TYPES[y] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[y] is (FUNC t_1* -> t_2*). |
| - the result type C.RETURN is ?(t'_2*). |
| - the result type t_2* matches the result type t'_2*. |
| - the instruction type t_3* -> t_4* is valid. |
| |
| Instr_ok/throw |
| - the instruction (THROW x) is valid with the instruction type t_1* :: t* -> t_2* if: |
| - the tag C.TAGS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of $as_deftype(C.TAGS[x]) is (FUNC t* -> []). |
| - the instruction type t_1* -> t_2* is valid. |
| |
| Instr_ok/throw_ref |
| - the instruction THROW_REF is valid with the instruction type t_1* :: [(REF ?(NULL) EXN)] -> t_2* if: |
| - the instruction type t_1* -> t_2* is valid. |
| |
| Instr_ok/try_table |
| - the instruction (TRY_TABLE bt catch* instr*) is valid with the instruction type t_1* -> t_2* if: |
| - the block type bt is valid as t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_2*]. |
| - Under the context C', the instruction sequence instr* is valid with the instruction type t_1* ->_ x* t_2*. |
| - For all catch in catch*: |
| - the catch clause catch is valid. |
| |
| Instr_ok/ref.null |
| - the instruction (REF.NULL ht) is valid with the instruction type [] -> [(REF ?(NULL) ht)] if: |
| - the heap type ht is valid. |
| |
| Instr_ok/ref.func |
| - the instruction (REF.FUNC x) is valid with the instruction type [] -> [(REF ?() dt)] if: |
| - the function C.FUNCS[x] exists. |
| - C.FUNCS[x] is dt. |
| - x is contained in C.REFS. |
| |
| Instr_ok/ref.i31 |
| - the instruction REF.I31 is valid with the instruction type [I32] -> [(REF ?() I31)]. |
| |
| Instr_ok/ref.is_null |
| - the instruction REF.IS_NULL is valid with the instruction type [(REF ?(NULL) ht)] -> [I32] if: |
| - the heap type ht is valid. |
| |
| Instr_ok/ref.as_non_null |
| - the instruction REF.AS_NON_NULL is valid with the instruction type [(REF ?(NULL) ht)] -> [(REF ?() ht)] if: |
| - the heap type ht is valid. |
| |
| Instr_ok/ref.eq |
| - the instruction REF.EQ is valid with the instruction type [(REF ?(NULL) EQ), (REF ?(NULL) EQ)] -> [I32]. |
| |
| Instr_ok/ref.test |
| - the instruction (REF.TEST rt) is valid with the instruction type [rt'] -> [I32] if: |
| - the reference type rt is valid. |
| - the reference type rt' is valid. |
| - rt matches rt'. |
| |
| Instr_ok/ref.cast |
| - the instruction (REF.CAST rt) is valid with the instruction type [rt'] -> [rt] if: |
| - the reference type rt is valid. |
| - the reference type rt' is valid. |
| - rt matches rt'. |
| |
| Instr_ok/i31.get |
| - the instruction (I31.GET sx) is valid with the instruction type [(REF ?(NULL) I31)] -> [I32]. |
| |
| Instr_ok/struct.new |
| - the instruction (STRUCT.NEW x) is valid with the instruction type t* -> [(REF ?() (_IDX x))] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (STRUCT (mut? zt)*). |
| - the value type sequence t* is $unpack(zt)*. |
| |
| Instr_ok/struct.new_default |
| - the instruction (STRUCT.NEW_DEFAULT x) is valid with the instruction type [] -> [(REF ?() (_IDX x))] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (STRUCT (mut? zt)*). |
| - For all zt in zt*: |
| - A :ref:`default value <aux-default>` for $unpack(zt) is defined. |
| |
| Instr_ok/struct.get |
| - the instruction (STRUCT.GET sx? x i) is valid with the instruction type [(REF ?(NULL) (_IDX x))] -> [t] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (STRUCT ft*). |
| - |ft*| is greater than i. |
| - the field type ft*[i] is (mut? zt). |
| - the signedness sx? is not ?() if and only if $is_packtype(zt). |
| - the value type t is $unpack(zt). |
| |
| Instr_ok/struct.set |
| - the instruction (STRUCT.SET x i) is valid with the instruction type [(REF ?(NULL) (_IDX x)), t] -> [] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (STRUCT ft*). |
| - |ft*| is greater than i. |
| - the field type ft*[i] is (?(MUT) zt). |
| - the value type t is $unpack(zt). |
| |
| Instr_ok/array.new |
| - the instruction (ARRAY.NEW x) is valid with the instruction type [t, I32] -> [(REF ?() (_IDX x))] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (mut? zt)). |
| - the value type t is $unpack(zt). |
| |
| Instr_ok/array.new_default |
| - the instruction (ARRAY.NEW_DEFAULT x) is valid with the instruction type [I32] -> [(REF ?() (_IDX x))] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (mut? zt)). |
| - A :ref:`default value <aux-default>` for $unpack(zt) is defined. |
| |
| Instr_ok/array.new_fixed |
| - the instruction (ARRAY.NEW_FIXED x n) is valid with the instruction type t^n -> [(REF ?() (_IDX x))] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (mut? zt)). |
| - the value type t is $unpack(zt). |
| |
| Instr_ok/array.new_elem |
| - the instruction (ARRAY.NEW_ELEM x y) is valid with the instruction type [I32, I32] -> [(REF ?() (_IDX x))] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (mut? rt)). |
| - the element segment C.ELEMS[y] exists. |
| - C.ELEMS[y] matches the reference type rt. |
| |
| Instr_ok/array.new_data |
| - the instruction (ARRAY.NEW_DATA x y) is valid with the instruction type [I32, I32] -> [(REF ?() (_IDX x))] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (mut? zt)). |
| - $unpack(zt) is numtype or the value type $unpack(zt) is vectype. |
| - the data segment C.DATAS[y] exists. |
| - C.DATAS[y] is OK. |
| |
| Instr_ok/array.get |
| - the instruction (ARRAY.GET sx? x) is valid with the instruction type [(REF ?(NULL) (_IDX x)), I32] -> [t] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (mut? zt)). |
| - the signedness sx? is not ?() if and only if $is_packtype(zt). |
| - the value type t is $unpack(zt). |
| |
| Instr_ok/array.set |
| - the instruction (ARRAY.SET x) is valid with the instruction type [(REF ?(NULL) (_IDX x)), I32, t] -> [] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (?(MUT) zt)). |
| - the value type t is $unpack(zt). |
| |
| Instr_ok/array.len |
| - the instruction ARRAY.LEN is valid with the instruction type [(REF ?(NULL) ARRAY)] -> [I32]. |
| |
| Instr_ok/array.fill |
| - the instruction (ARRAY.FILL x) is valid with the instruction type [(REF ?(NULL) (_IDX x)), I32, t, I32] -> [] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (?(MUT) zt)). |
| - the value type t is $unpack(zt). |
| |
| Instr_ok/array.copy |
| - the instruction (ARRAY.COPY x_1 x_2) is valid with the instruction type [(REF ?(NULL) (_IDX x_1)), I32, (REF ?(NULL) (_IDX x_2)), I32, I32] -> [] if: |
| - the type C.TYPES[x_1] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x_1] is (ARRAY (?(MUT) zt_1)). |
| - the type C.TYPES[x_2] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x_2] is (ARRAY (mut? zt_2)). |
| - the storage type zt_2 matches the storage type zt_1. |
| |
| Instr_ok/array.init_elem |
| - the instruction (ARRAY.INIT_ELEM x y) is valid with the instruction type [(REF ?(NULL) (_IDX x)), I32, I32, I32] -> [] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (?(MUT) zt)). |
| - the element segment C.ELEMS[y] exists. |
| - C.ELEMS[y] matches the storage type zt. |
| |
| Instr_ok/array.init_data |
| - the instruction (ARRAY.INIT_DATA x y) is valid with the instruction type [(REF ?(NULL) (_IDX x)), I32, I32, I32] -> [] if: |
| - the type C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (ARRAY (?(MUT) zt)). |
| - $unpack(zt) is numtype or the value type $unpack(zt) is vectype. |
| - the data segment C.DATAS[y] exists. |
| - C.DATAS[y] is OK. |
| |
| Instr_ok/extern.convert_any |
| - the instruction EXTERN.CONVERT_ANY is valid with the instruction type [(REF null_1? ANY)] -> [(REF null_2? EXTERN)] if: |
| - null_1? is null_2?. |
| |
| Instr_ok/any.convert_extern |
| - the instruction ANY.CONVERT_EXTERN is valid with the instruction type [(REF null_1? EXTERN)] -> [(REF null_2? ANY)] if: |
| - null_1? is null_2?. |
| |
| Instr_ok/local.get |
| - the instruction (LOCAL.GET x) is valid with the instruction type [] -> [t] if: |
| - the local C.LOCALS[x] exists. |
| - C.LOCALS[x] is (SET t). |
| |
| Instr_ok/local.set |
| - the instruction (LOCAL.SET x) is valid with the instruction type [t] ->_ [x] [] if: |
| - the local C.LOCALS[x] exists. |
| - C.LOCALS[x] is (init t). |
| |
| Instr_ok/local.tee |
| - the instruction (LOCAL.TEE x) is valid with the instruction type [t] ->_ [x] [t] if: |
| - the local C.LOCALS[x] exists. |
| - C.LOCALS[x] is (init t). |
| |
| Instr_ok/global.get |
| - the instruction (GLOBAL.GET x) is valid with the instruction type [] -> [t] if: |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (mut? t). |
| |
| Instr_ok/global.set |
| - the instruction (GLOBAL.SET x) is valid with the instruction type [t] -> [] if: |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?(MUT) t). |
| |
| Instr_ok/table.get |
| - the instruction (TABLE.GET x) is valid with the instruction type [at] -> [rt] if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt). |
| |
| Instr_ok/table.set |
| - the instruction (TABLE.SET x) is valid with the instruction type [at, rt] -> [] if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt). |
| |
| Instr_ok/table.size |
| - the instruction (TABLE.SIZE x) is valid with the instruction type [] -> [at] if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt). |
| |
| Instr_ok/table.grow |
| - the instruction (TABLE.GROW x) is valid with the instruction type [rt, at] -> [at] if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt). |
| |
| Instr_ok/table.fill |
| - the instruction (TABLE.FILL x) is valid with the instruction type [at, rt, at] -> [] if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt). |
| |
| Instr_ok/table.copy |
| - the instruction (TABLE.COPY x_1 x_2) is valid with the instruction type [at_1, at_2, addrtype] -> [] if: |
| - the table C.TABLES[x_1] exists. |
| - C.TABLES[x_1] is (at_1 lim_1 rt_1). |
| - the table C.TABLES[x_2] exists. |
| - C.TABLES[x_2] is (at_2 lim_2 rt_2). |
| - the reference type rt_2 matches the reference type rt_1. |
| - the address type addrtype is $minat(at_1, at_2). |
| |
| Instr_ok/table.init |
| - the instruction (TABLE.INIT x y) is valid with the instruction type [at, I32, I32] -> [] if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt_1). |
| - the element segment C.ELEMS[y] exists. |
| - C.ELEMS[y] is rt_2. |
| - the reference type rt_2 matches the reference type rt_1. |
| |
| Instr_ok/elem.drop |
| - the instruction (ELEM.DROP x) is valid with the instruction type [] -> [] if: |
| - the element segment C.ELEMS[x] exists. |
| |
| Instr_ok/memory.size |
| - the instruction (MEMORY.SIZE x) is valid with the instruction type [] -> [at] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| |
| Instr_ok/memory.grow |
| - the instruction (MEMORY.GROW x) is valid with the instruction type [at] -> [at] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| |
| Instr_ok/memory.fill |
| - the instruction (MEMORY.FILL x) is valid with the instruction type [at, I32, at] -> [] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| |
| Instr_ok/memory.copy |
| - the instruction (MEMORY.COPY x_1 x_2) is valid with the instruction type [at_1, at_2, addrtype] -> [] if: |
| - the memory C.MEMS[x_1] exists. |
| - C.MEMS[x_1] is at_1 lim_1 PAGE. |
| - the memory C.MEMS[x_2] exists. |
| - C.MEMS[x_2] is at_2 lim_2 PAGE. |
| - the address type addrtype is $minat(at_1, at_2). |
| |
| Instr_ok/memory.init |
| - the instruction (MEMORY.INIT x y) is valid with the instruction type [at, I32, I32] -> [] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - the data segment C.DATAS[y] exists. |
| - C.DATAS[y] is OK. |
| |
| Instr_ok/data.drop |
| - the instruction (DATA.DROP x) is valid with the instruction type [] -> [] if: |
| - the data segment C.DATAS[x] exists. |
| - C.DATAS[x] is OK. |
| |
| Instr_ok/load |
| - the instruction (LOAD nt loadop_? x memarg) is valid with the instruction type [at] -> [valtype] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - Either: |
| - loadop_? is ?(). |
| - the value type valtype is nt. |
| - memarg is valid for at and $size(nt). |
| - Or: |
| - the number type nt is Inn. |
| - loadop_? is ?(K _ sx). |
| - valtype is Inn. |
| - memarg is valid for at and K. |
| |
| Instr_ok/store |
| - the instruction (STORE nt storeop_? x memarg) is valid with the instruction type [at, valtype] -> [] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - Either: |
| - storeop_? is ?(). |
| - the value type valtype is nt. |
| - memarg is valid for at and $size(nt). |
| - Or: |
| - the number type nt is Inn. |
| - storeop_? is ?(K). |
| - valtype is Inn. |
| - memarg is valid for at and K. |
| |
| Instr_ok/vload |
| - the instruction (VLOAD V128 vloadop_? x memarg) is valid with the instruction type [at] -> [V128] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - Either: |
| - vloadop_? is ?(). |
| - memarg is valid for at and $vsize(V128). |
| - Or: |
| - vloadop_? is ?((SHAPE N X M _ sx)). |
| - memarg is valid for at and (N * M). |
| - Or: |
| - vloadop_? is ?((SPLAT N)). |
| - memarg is valid for at and N. |
| - Or: |
| - vloadop_? is ?((ZERO N)). |
| - memarg is valid for at and N. |
| |
| Instr_ok/vload_lane |
| - the instruction (VLOAD_LANE V128 N x memarg i) is valid with the instruction type [at, V128] -> [V128] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and N. |
| - i is less than (128 / N). |
| |
| Instr_ok/vstore |
| - the instruction (VSTORE V128 x memarg) is valid with the instruction type [at, V128] -> [] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and $vsize(V128). |
| |
| Instr_ok/vstore_lane |
| - the instruction (VSTORE_LANE V128 N x memarg i) is valid with the instruction type [at, V128] -> [] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and N. |
| - i is less than (128 / N). |
| |
| Instr_ok/const |
| - the instruction (nt.CONST c_nt) is valid with the instruction type [] -> [nt]. |
| |
| Instr_ok/unop |
| - the instruction (UNOP nt unop_nt) is valid with the instruction type [nt] -> [nt]. |
| |
| Instr_ok/binop |
| - the instruction (BINOP nt binop_nt) is valid with the instruction type [nt, nt] -> [nt]. |
| |
| Instr_ok/testop |
| - the instruction (TESTOP nt testop_nt) is valid with the instruction type [nt] -> [I32]. |
| |
| Instr_ok/relop |
| - the instruction (RELOP nt relop_nt) is valid with the instruction type [nt, nt] -> [I32]. |
| |
| Instr_ok/cvtop |
| - the instruction (CVTOP nt_1 nt_2 cvtop) is valid with the instruction type [nt_2] -> [nt_1]. |
| |
| Instr_ok/vconst |
| - the instruction (V128.CONST c) is valid with the instruction type [] -> [V128]. |
| |
| Instr_ok/vvunop |
| - the instruction (VVUNOP V128 vvunop) is valid with the instruction type [V128] -> [V128]. |
| |
| Instr_ok/vvbinop |
| - the instruction (VVBINOP V128 vvbinop) is valid with the instruction type [V128, V128] -> [V128]. |
| |
| Instr_ok/vvternop |
| - the instruction (VVTERNOP V128 vvternop) is valid with the instruction type [V128, V128, V128] -> [V128]. |
| |
| Instr_ok/vvtestop |
| - the instruction (VVTESTOP V128 vvtestop) is valid with the instruction type [V128] -> [I32]. |
| |
| Instr_ok/vunop |
| - the instruction (VUNOP sh vunop) is valid with [V128] -> [V128]. |
| |
| Instr_ok/vbinop |
| - the instruction (VBINOP sh vbinop) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vternop |
| - the instruction (VTERNOP sh vternop) is valid with [V128, V128, V128] -> [V128]. |
| |
| Instr_ok/vtestop |
| - the instruction (VTESTOP sh vtestop) is valid with [V128] -> [I32]. |
| |
| Instr_ok/vrelop |
| - the instruction (VRELOP sh vrelop) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vshiftop |
| - the instruction (VSHIFTOP sh vshiftop) is valid with the instruction type [V128, I32] -> [V128]. |
| |
| Instr_ok/vbitmask |
| - the instruction (VBITMASK sh) is valid with [V128] -> [I32]. |
| |
| Instr_ok/vswizzlop |
| - the instruction (VSWIZZLOP sh vswizzlop) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vshuffle |
| - the instruction (VSHUFFLE sh i*) is valid with the instruction type [V128, V128] -> [V128] if: |
| - For all i in i*: |
| - the lane index i is less than (2 * $dim(sh)). |
| |
| Instr_ok/vsplat |
| - the instruction (VSPLAT sh) is valid with the instruction type [numtype] -> [V128] if: |
| - the number type numtype is $unpackshape(sh). |
| |
| Instr_ok/vextract_lane |
| - the instruction (VEXTRACT_LANE sh sx? i) is valid with the instruction type [V128] -> [numtype] if: |
| - the lane index i is less than $dim(sh). |
| - the number type numtype is $unpackshape(sh). |
| |
| Instr_ok/vreplace_lane |
| - the instruction (VREPLACE_LANE sh i) is valid with the instruction type [V128, numtype] -> [V128] if: |
| - the lane index i is less than $dim(sh). |
| - the number type numtype is $unpackshape(sh). |
| |
| Instr_ok/vextunop |
| - the instruction (VEXTUNOP sh_1 sh_2 vextunop) is valid with the instruction type [V128] -> [V128]. |
| |
| Instr_ok/vextbinop |
| - the instruction (VEXTBINOP sh_1 sh_2 vextbinop) is valid with the instruction type [V128, V128] -> [V128]. |
| |
| Instr_ok/vextternop |
| - the instruction (VEXTTERNOP sh_1 sh_2 vextternop) is valid with the instruction type [V128, V128, V128] -> [V128]. |
| |
| Instr_ok/vnarrow |
| - the instruction (VNARROW sh_1 sh_2 sx) is valid with [V128, V128] -> [V128]. |
| |
| Instr_ok/vcvtop |
| - the instruction (VCVTOP sh_1 sh_2 vcvtop) is valid with [V128] -> [V128]. |
| |
| Instr_ok/select-expl |
| - the instruction (SELECT ?([t])) is valid with the instruction type [t, t, I32] -> [t] if: |
| - the value type t is valid. |
| |
| Instr_ok/select-impl |
| - the instruction (SELECT ?()) is valid with the instruction type [t, t, I32] -> [t] if: |
| - the value type t is valid. |
| - t matches the value type t'. |
| - t' is numtype or t' is vectype. |
| |
| Instr_ok/load-val |
| - the instruction (LOAD nt ?() x memarg) is valid with the instruction type [at] -> [nt] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and $size(nt). |
| |
| Instr_ok/load-pack |
| - the instruction (LOAD Inn ?(K _ sx) x memarg) is valid with the instruction type [at] -> [Inn] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and K. |
| |
| Instr_ok/store-val |
| - the instruction (STORE nt ?() x memarg) is valid with the instruction type [at, nt] -> [] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and $size(nt). |
| |
| Instr_ok/store-pack |
| - the instruction (STORE Inn ?(K) x memarg) is valid with the instruction type [at, Inn] -> [] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and K. |
| |
| Instr_ok/vload-val |
| - the instruction (VLOAD V128 ?() x memarg) is valid with the instruction type [at] -> [V128] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and $vsize(V128). |
| |
| Instr_ok/vload-pack |
| - the instruction (VLOAD V128 ?((SHAPE N X M _ sx)) x memarg) is valid with the instruction type [at] -> [V128] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and (N * M). |
| |
| Instr_ok/vload-splat |
| - the instruction (VLOAD V128 ?((SPLAT N)) x memarg) is valid with the instruction type [at] -> [V128] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and N. |
| |
| Instr_ok/vload-zero |
| - the instruction (VLOAD V128 ?((ZERO N)) x memarg) is valid with the instruction type [at] -> [V128] if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - memarg is valid for at and N. |
| |
| Instrs_ok |
| - the instruction sequence instr* is valid with the instruction type it if: |
| - Either: |
| - instr* is []. |
| - it is [] -> []. |
| - Or: |
| - instr* is [instr_1] :: instr_2*. |
| - it is t_1* ->_ x_1* :: x_2* t_3*. |
| - the instruction instr_1 is valid with the instruction type t_1* ->_ x_1* t_2*. |
| - For all x_1 in x_1*: |
| - the local C.LOCALS[x_1] exists. |
| - C.LOCALS[x_1] is (init t). |
| - Under the context $with_locals(C, x_1*, (SET t)*), the instruction sequence instr_2* is valid with the instruction type t_2* ->_ x_2* t_3*. |
| - Or: |
| - instr* is valid with the instruction type it''. |
| - it'' matches it. |
| - it is valid. |
| - Or: |
| - it is t* :: t_1* ->_ x* t* :: t_2*. |
| - instr* is valid with the instruction type t_1* ->_ x* t_2*. |
| - the result type t* is valid. |
| |
| Instrs_ok/empty |
| - the instruction sequence [] is valid with the instruction type [] -> []. |
| |
| Instrs_ok/seq |
| - the instruction sequence [instr_1] :: instr_2* is valid with the instruction type t_1* ->_ x_1* :: x_2* t_3* if: |
| - the instruction instr_1 is valid with the instruction type t_1* ->_ x_1* t_2*. |
| - For all x_1 in x_1*: |
| - the local C.LOCALS[x_1] exists. |
| - C.LOCALS[x_1] is (init t). |
| - t* is the concatenation of all such t. |
| - Under the context $with_locals(C, x_1*, (SET t)*), the instruction sequence instr_2* is valid with the instruction type t_2* ->_ x_2* t_3*. |
| |
| Instrs_ok/sub |
| - the instruction sequence instr* is valid with the instruction type it if: |
| - instr* is valid with the instruction type it'. |
| - it' matches it. |
| - it is valid. |
| |
| Instrs_ok/frame |
| - the instruction sequence instr* is valid with the instruction type t* :: t_1* ->_ x* t* :: t_2* if: |
| - instr* is valid with the instruction type t_1* ->_ x* t_2*. |
| - the result type t* is valid. |
| |
| Expr_ok |
| - the expression instr* is valid with the result type t* if: |
| - instr* is valid with the instruction type [] -> t*. |
| |
| Nondefaultable |
| - the value type t is not defaultable if: |
| - the value $default_(t) is ?(). |
| |
| Instr_const |
| - the instruction instr is constant if: |
| - Either: |
| - instr is (nt.CONST c_nt). |
| - Or: |
| - instr is (vt.CONST c_vt). |
| - Or: |
| - instr is (REF.NULL ht). |
| - Or: |
| - instr is REF.I31. |
| - Or: |
| - instr is (REF.FUNC x). |
| - Or: |
| - instr is (STRUCT.NEW x). |
| - Or: |
| - instr is (STRUCT.NEW_DEFAULT x). |
| - Or: |
| - instr is (ARRAY.NEW x). |
| - Or: |
| - instr is (ARRAY.NEW_DEFAULT x). |
| - Or: |
| - instr is (ARRAY.NEW_FIXED x n). |
| - Or: |
| - instr is ANY.CONVERT_EXTERN. |
| - Or: |
| - instr is EXTERN.CONVERT_ANY. |
| - Or: |
| - instr is (GLOBAL.GET x). |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?() t). |
| - Or: |
| - instr is (BINOP Inn binop). |
| - Inn is contained in [I32, I64]. |
| - binop is contained in [ADD, SUB, MUL]. |
| |
| Instr_const/const |
| - the instruction (nt.CONST c_nt) is constant. |
| |
| Instr_const/vconst |
| - the instruction (vt.CONST c_vt) is constant. |
| |
| Instr_const/ref.null |
| - the instruction (REF.NULL ht) is constant. |
| |
| Instr_const/ref.i31 |
| - the instruction REF.I31 is constant. |
| |
| Instr_const/ref.func |
| - the instruction (REF.FUNC x) is constant. |
| |
| Instr_const/struct.new |
| - the instruction (STRUCT.NEW x) is constant. |
| |
| Instr_const/struct.new_default |
| - the instruction (STRUCT.NEW_DEFAULT x) is constant. |
| |
| Instr_const/array.new |
| - the instruction (ARRAY.NEW x) is constant. |
| |
| Instr_const/array.new_default |
| - the instruction (ARRAY.NEW_DEFAULT x) is constant. |
| |
| Instr_const/array.new_fixed |
| - the instruction (ARRAY.NEW_FIXED x n) is constant. |
| |
| Instr_const/any.convert_extern |
| - the instruction ANY.CONVERT_EXTERN is constant. |
| |
| Instr_const/extern.convert_any |
| - the instruction EXTERN.CONVERT_ANY is constant. |
| |
| Instr_const/global.get |
| - the instruction (GLOBAL.GET x) is constant if: |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?() t). |
| |
| Instr_const/binop |
| - the instruction (BINOP Inn binop) is constant if: |
| - Inn is contained in [I32, I64]. |
| - binop is contained in [ADD, SUB, MUL]. |
| |
| Expr_const |
| - the expression instr* is constant if: |
| - For all instr in instr*: |
| - the instruction instr is constant. |
| |
| Type_ok |
| - the type definition (TYPE rectype) is valid with the defined type sequence dt* if: |
| - |C.TYPES| is x. |
| - dt* is $rolldt(x, rectype). |
| - the context C' is the context C with .TYPES appended by dt*. |
| - Under the context C', the recursive type rectype is valid for the type index (OK x). |
| |
| Tag_ok |
| - the tag (TAG tagtype) is valid with the tag type tagtype' if: |
| - the tag type tagtype is valid. |
| - tagtype' is $clos_tagtype(C, tagtype). |
| |
| Global_ok |
| - the global (GLOBAL globaltype expr) is valid with the global type globaltype if: |
| - globaltype is valid. |
| - globaltype is (MUT? t). |
| - the expression expr is valid with the value type t. |
| - expr is constant. |
| |
| Mem_ok |
| - the memory (MEMORY memtype) is valid with the memory type memtype if: |
| - memtype is valid. |
| |
| Table_ok |
| - the table (TABLE tabletype expr) is valid with the table type tabletype if: |
| - tabletype is valid. |
| - tabletype is (at lim rt). |
| - the expression expr is valid with the value type rt. |
| - expr is constant. |
| |
| Local_ok |
| - the local (LOCAL t) is valid with the local type (init t) if: |
| - Either: |
| - the initialization status init is SET. |
| - A :ref:`default value <aux-default>` for t is defined. |
| - Or: |
| - init is UNSET. |
| - A :ref:`default value <aux-default>` for t is not defined. |
| |
| Local_ok/set |
| - the local (LOCAL t) is valid with the local type (SET t) if: |
| - A :ref:`default value <aux-default>` for t is defined. |
| |
| Local_ok/unset |
| - the local (LOCAL t) is valid with the local type (UNSET t) if: |
| - A :ref:`default value <aux-default>` for t is not defined. |
| |
| Func_ok |
| - the function (FUNC x local* expr) is valid with the type C.TYPES[x] if: |
| - C.TYPES[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.TYPES[x] is (FUNC t_1* -> t_2*). |
| - For all local in local*: |
| - the local local is valid with the local type lct. |
| - lct* is the concatenation of all such lct. |
| - Under the context C with .LOCALS appended by (SET t_1)* :: lct* and .LABELS appended by [t_2*] and .RETURN appended by ?(t_2*), the expression expr is valid with the result type t_2*. |
| |
| Datamode_ok |
| - the data mode datamode is valid if: |
| - Either: |
| - datamode is PASSIVE. |
| - Or: |
| - datamode is (ACTIVE x expr). |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - the expression expr is valid with the value type at. |
| - expr is constant. |
| |
| Datamode_ok/passive |
| - the data mode PASSIVE is always valid. |
| |
| Datamode_ok/active |
| - the data mode (ACTIVE x expr) is valid if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is at lim PAGE. |
| - the expression expr is valid with the value type at. |
| - expr is constant. |
| |
| Data_ok |
| - the memory segment (DATA b* datamode) is valid if: |
| - the data mode datamode is valid. |
| |
| Elemmode_ok |
| - the element mode elemmode is valid with the element type rt if: |
| - Either: |
| - elemmode is PASSIVE. |
| - Or: |
| - elemmode is DECLARE. |
| - Or: |
| - elemmode is (ACTIVE x expr). |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt'). |
| - rt matches the reference type rt'. |
| - the expression expr is valid with the value type at. |
| - expr is constant. |
| |
| Elemmode_ok/passive |
| - the element mode PASSIVE is valid with rt. |
| |
| Elemmode_ok/declare |
| - the element mode DECLARE is valid with rt. |
| |
| Elemmode_ok/active |
| - the element mode (ACTIVE x expr) is valid with the element type rt if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is (at lim rt'). |
| - rt matches the reference type rt'. |
| - the expression expr is valid with the value type at. |
| - expr is constant. |
| |
| Elem_ok |
| - the table segment (ELEM elemtype expr* elemmode) is valid with the element type elemtype if: |
| - elemtype is valid. |
| - For all expr in expr*: |
| - the expression expr is valid with elemtype. |
| - expr is constant. |
| - the element mode elemmode is valid with elemtype. |
| |
| Start_ok |
| - the start function (START x) is valid if: |
| - the function C.FUNCS[x] exists. |
| - The :ref:`expansion <aux-expand-deftype>` of C.FUNCS[x] is (FUNC [] -> []). |
| |
| Import_ok |
| - the import (IMPORT name_1 name_2 xt) is valid with the external type externtype if: |
| - the external type xt is valid. |
| - externtype is $clos_externtype(C, xt). |
| |
| Externidx_ok |
| - the external index externidx is valid with the external type externtype if: |
| - Either: |
| - externidx is (TAG x). |
| - externtype is (TAG jt). |
| - the tag C.TAGS[x] exists. |
| - C.TAGS[x] is jt. |
| - Or: |
| - externidx is (GLOBAL x). |
| - externtype is (GLOBAL gt). |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is gt. |
| - Or: |
| - externidx is (MEM x). |
| - externtype is (MEM mt). |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is mt. |
| - Or: |
| - externidx is (TABLE x). |
| - externtype is (TABLE tt). |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is tt. |
| - Or: |
| - externidx is (FUNC x). |
| - externtype is (FUNC dt). |
| - the function C.FUNCS[x] exists. |
| - C.FUNCS[x] is dt. |
| |
| Externidx_ok/tag |
| - the external index (TAG x) is valid with the external type (TAG jt) if: |
| - the tag C.TAGS[x] exists. |
| - C.TAGS[x] is jt. |
| |
| Externidx_ok/global |
| - the external index (GLOBAL x) is valid with the external type (GLOBAL gt) if: |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is gt. |
| |
| Externidx_ok/mem |
| - the external index (MEM x) is valid with the external type (MEM mt) if: |
| - the memory C.MEMS[x] exists. |
| - C.MEMS[x] is mt. |
| |
| Externidx_ok/table |
| - the external index (TABLE x) is valid with the external type (TABLE tt) if: |
| - the table C.TABLES[x] exists. |
| - C.TABLES[x] is tt. |
| |
| Externidx_ok/func |
| - the external index (FUNC x) is valid with the external type (FUNC dt) if: |
| - the function C.FUNCS[x] exists. |
| - C.FUNCS[x] is dt. |
| |
| Export_ok |
| - the export (EXPORT name externidx) is valid with the name name and the external type xt if: |
| - the external index externidx is valid with xt. |
| |
| Globals_ok |
| - the global sequence global* is valid with the global type sequence globaltype* if: |
| - Either: |
| - global* is []. |
| - globaltype* is []. |
| - Or: |
| - global* is [global_1] :: global'*. |
| - globaltype* is [gt_1] :: gt*. |
| - the global global_1 is valid with the global type gt_1. |
| - the context C' is the context C with .GLOBALS appended by [gt_1]. |
| - Under the context C', the global sequence global'* is valid with the global type sequence gt*. |
| |
| Globals_ok/empty |
| - [] is valid with the global type sequence []. |
| |
| Globals_ok/cons |
| - the global sequence [global_1] :: global* is valid with the global type sequence [gt_1] :: gt* if: |
| - the global global_1 is valid with the global type gt_1. |
| - the context C' is the context C with .GLOBALS appended by [gt_1]. |
| - Under the context C', the global sequence global* is valid with the global type sequence gt*. |
| |
| Types_ok |
| - the type definition sequence type* is valid with the defined type sequence deftype* if: |
| - Either: |
| - type* is []. |
| - deftype* is []. |
| - Or: |
| - type* is [type_1] :: type'*. |
| - deftype* is dt_1* :: dt*. |
| - the type definition type_1 is valid with the defined type sequence dt_1*. |
| - the context C' is the context C with .TYPES appended by dt_1*. |
| - Under the context C', the type definition sequence type'* is valid with the defined type sequence dt*. |
| |
| Types_ok/empty |
| - [] is valid with the defined type sequence []. |
| |
| Types_ok/cons |
| - the type definition sequence [type_1] :: type* is valid with the defined type sequence dt_1* :: dt* if: |
| - the type definition type_1 is valid with the defined type sequence dt_1*. |
| - the context C' is the context C with .TYPES appended by dt_1*. |
| - Under the context C', the type definition sequence type* is valid with the defined type sequence dt*. |
| |
| Module_ok |
| - the module (MODULE type* import* tag* global* mem* table* func* data* elem* start? export*) is valid with the module type moduletype if: |
| - Under the context { RETURN: ?() }, the type definition sequence type* is valid with the defined type sequence dt'*. |
| - For all import in import*: |
| - Under the context { TYPES: dt'*; RETURN: ?() }, the import import is valid with the external type xt_I. |
| - xt_I* is the concatenation of all such xt_I. |
| - For all tag in tag*: |
| - Under the context C', the tag tag is valid with the tag type jt. |
| - jt* is the concatenation of all such jt. |
| - Under the context C', the global sequence global* is valid with the global type sequence gt*. |
| - For all mem in mem*: |
| - Under the context C', the memory mem is valid with the memory type mt. |
| - mt* is the concatenation of all such mt. |
| - For all table in table*: |
| - Under the context C', the table table is valid with the table type tt. |
| - tt* is the concatenation of all such tt. |
| - For all func in func*: |
| - the function func is valid with the defined type dt. |
| - dt* is the concatenation of all such dt. |
| - For all data in data*: |
| - the memory segment data is valid. |
| - ok* is the concatenation of all such ok. |
| - For all elem in elem*: |
| - the table segment elem is valid with the element type rt. |
| - rt* is the concatenation of all such rt. |
| - If start is defined, then: |
| - the start function start is valid. |
| - For all export in export*: |
| - the export export is valid with the name nm and the external type xt_E. |
| - nm* is the concatenation of all such nm. |
| - xt_E* is the concatenation of all such xt_E. |
| - $disjoint_(`name, nm*) is true. |
| - the context C is C' with .TAGS appended by jt_I* :: jt* and .GLOBALS appended by gt* and .MEMS appended by mt_I* :: mt* and .TABLES appended by tt_I* :: tt* and .DATAS appended by ok* and .ELEMS appended by rt*. |
| - the context C' is { TYPES: dt'*; GLOBALS: gt_I*; FUNCS: dt_I* :: dt*; RETURN: ?(); REFS: x* }. |
| - the function index sequence x* is $funcidx_nonfuncs((global* mem* table* elem* start? export*)). |
| - the tag type sequence jt_I* is $tagsxt(xt_I*). |
| - the global type sequence gt_I* is $globalsxt(xt_I*). |
| - the memory type sequence mt_I* is $memsxt(xt_I*). |
| - the table type sequence tt_I* is $tablesxt(xt_I*). |
| - the defined type sequence dt_I* is $funcsxt(xt_I*). |
| - moduletype is $clos_moduletype(C, xt_I* -> xt_E*). |
| |
| Num_ok |
| - the number value (nt.CONST c) is valid with the number type nt. |
| |
| Vec_ok |
| - the vector value (vt.CONST c) is valid with the vector type vt. |
| |
| Ref_ok |
| - the reference value ref is valid with the reference type rt if: |
| - Either: |
| - ref is REF.NULL_ADDR. |
| - rt is (REF ?(NULL) BOT). |
| - Or: |
| - ref is (REF.I31_NUM i). |
| - rt is (REF ?() I31). |
| - Or: |
| - ref is (REF.STRUCT_ADDR a). |
| - rt is (REF ?() dt). |
| - the structure instance s.STRUCTS[a] exists. |
| - the defined type s.STRUCTS[a].TYPE is dt. |
| - Or: |
| - ref is (REF.ARRAY_ADDR a). |
| - rt is (REF ?() dt). |
| - the array instance s.ARRAYS[a] exists. |
| - the defined type s.ARRAYS[a].TYPE is dt. |
| - Or: |
| - ref is (REF.FUNC_ADDR a). |
| - rt is (REF ?() dt). |
| - the function instance s.FUNCS[a] exists. |
| - the defined type s.FUNCS[a].TYPE is dt. |
| - Or: |
| - ref is (REF.EXN_ADDR a). |
| - rt is (REF ?() EXN). |
| - the exception instance s.EXNS[a] exists. |
| - Or: |
| - ref is (REF.HOST_ADDR a). |
| - rt is (REF ?() ANY). |
| - Or: |
| - ref is (REF.EXTERN ref'). |
| - rt is (REF ?() EXTERN). |
| - the reference value ref' is valid with the reference type (REF ?() ANY). |
| - ref' is not REF.NULL_ADDR. |
| - Or: |
| - ref is valid with the reference type rt'. |
| - Under the context { RETURN: ?() }, rt is valid. |
| - rt' matches rt. |
| |
| Ref_ok/null |
| - the reference value REF.NULL_ADDR is valid with the reference type (REF ?(NULL) BOT). |
| |
| Ref_ok/i31 |
| - the reference value (REF.I31_NUM i) is valid with the reference type (REF ?() I31). |
| |
| Ref_ok/struct |
| - the reference value (REF.STRUCT_ADDR a) is valid with the reference type (REF ?() dt) if: |
| - the structure instance s.STRUCTS[a] exists. |
| - the defined type s.STRUCTS[a].TYPE is dt. |
| |
| Ref_ok/array |
| - the reference value (REF.ARRAY_ADDR a) is valid with the reference type (REF ?() dt) if: |
| - the array instance s.ARRAYS[a] exists. |
| - the defined type s.ARRAYS[a].TYPE is dt. |
| |
| Ref_ok/func |
| - the reference value (REF.FUNC_ADDR a) is valid with the reference type (REF ?() dt) if: |
| - the function instance s.FUNCS[a] exists. |
| - the defined type s.FUNCS[a].TYPE is dt. |
| |
| Ref_ok/exn |
| - the reference value (REF.EXN_ADDR a) is valid with the reference type (REF ?() EXN) if: |
| - the exception instance s.EXNS[a] exists. |
| |
| Ref_ok/host |
| - the reference value (REF.HOST_ADDR a) is valid with the reference type (REF ?() ANY). |
| |
| Ref_ok/extern |
| - the reference value (REF.EXTERN ref) is valid with the reference type (REF ?() EXTERN) if: |
| - the reference value ref is valid with the reference type (REF ?() ANY). |
| - ref is not REF.NULL_ADDR. |
| |
| Ref_ok/sub |
| - the reference value ref is valid with the reference type rt if: |
| - ref is valid with the reference type rt'. |
| - Under the context { RETURN: ?() }, rt is valid. |
| - rt' matches rt. |
| |
| Val_ok |
| - the value val is valid with the value type valtype if: |
| - Either: |
| - val is num. |
| - valtype is nt. |
| - the number value num is valid with the number type nt. |
| - Or: |
| - val is vec. |
| - valtype is vt. |
| - the vector value vec is valid with the vector type vt. |
| - Or: |
| - val is ref. |
| - valtype is rt. |
| - the reference value ref is valid with the reference type rt. |
| |
| Val_ok/num |
| - the value num is valid with the value type nt if: |
| - num is valid with nt. |
| |
| Val_ok/vec |
| - the value vec is valid with the value type vt if: |
| - vec is valid with vt. |
| |
| Val_ok/ref |
| - the value ref is valid with the value type rt if: |
| - ref is valid with rt. |
| |
| Packval_ok |
| - the packed value (PACK pt c) is valid with the packed type pt. |
| |
| Fieldval_ok |
| - the field value fieldval is valid with the storage type storagetype if: |
| - Either: |
| - fieldval is val. |
| - storagetype is t. |
| - the value val is valid with the value type t. |
| - Or: |
| - fieldval is packval. |
| - storagetype is pt. |
| - the packed value packval is valid with the packed type pt. |
| |
| Fieldval_ok/val |
| - the field value val is valid with the storage type t if: |
| - val is valid with t. |
| |
| Fieldval_ok/packval |
| - the field value packval is valid with the storage type pt if: |
| - packval is valid with pt. |
| |
| Externaddr_ok |
| - the external address externaddr is valid with the external type externtype if: |
| - Either: |
| - externaddr is (TAG a). |
| - externtype is (TAG taginst.TYPE). |
| - the tag instance s.TAGS[a] exists. |
| - s.TAGS[a] is taginst. |
| - Or: |
| - externaddr is (GLOBAL a). |
| - externtype is (GLOBAL globalinst.TYPE). |
| - the global instance s.GLOBALS[a] exists. |
| - s.GLOBALS[a] is globalinst. |
| - Or: |
| - externaddr is (MEM a). |
| - externtype is (MEM meminst.TYPE). |
| - the memory instance s.MEMS[a] exists. |
| - s.MEMS[a] is meminst. |
| - Or: |
| - externaddr is (TABLE a). |
| - externtype is (TABLE tableinst.TYPE). |
| - the table instance s.TABLES[a] exists. |
| - s.TABLES[a] is tableinst. |
| - Or: |
| - externaddr is (FUNC a). |
| - externtype is (FUNC funcinst.TYPE). |
| - the function instance s.FUNCS[a] exists. |
| - s.FUNCS[a] is funcinst. |
| - Or: |
| - externaddr is valid with the external type xt'. |
| - Under the context { RETURN: ?() }, externtype is valid. |
| - xt' matches externtype. |
| |
| Externaddr_ok/tag |
| - the external address (TAG a) is valid with the external type (TAG taginst.TYPE) if: |
| - the tag instance s.TAGS[a] exists. |
| - s.TAGS[a] is taginst. |
| |
| Externaddr_ok/global |
| - the external address (GLOBAL a) is valid with the external type (GLOBAL globalinst.TYPE) if: |
| - the global instance s.GLOBALS[a] exists. |
| - s.GLOBALS[a] is globalinst. |
| |
| Externaddr_ok/mem |
| - the external address (MEM a) is valid with the external type (MEM meminst.TYPE) if: |
| - the memory instance s.MEMS[a] exists. |
| - s.MEMS[a] is meminst. |
| |
| Externaddr_ok/table |
| - the external address (TABLE a) is valid with the external type (TABLE tableinst.TYPE) if: |
| - the table instance s.TABLES[a] exists. |
| - s.TABLES[a] is tableinst. |
| |
| Externaddr_ok/func |
| - the external address (FUNC a) is valid with the external type (FUNC funcinst.TYPE) if: |
| - the function instance s.FUNCS[a] exists. |
| - s.FUNCS[a] is funcinst. |
| |
| Externaddr_ok/sub |
| - the external address externaddr is valid with the external type xt if: |
| - externaddr is valid with the external type xt'. |
| - Under the context { RETURN: ?() }, xt is valid. |
| - xt' matches xt. |
| |
| Idctxt_ok |
| - the identifier context I is valid if: |
| - $disjoint_(`name, $concatopt_(`name, I.TYPES)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.TAGS)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.GLOBALS)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.MEMS)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.TABLES)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.FUNCS)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.DATAS)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.ELEMS)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.LOCALS)) is true. |
| - $disjoint_(`name, $concatopt_(`name, I.LABELS)) is true. |
| - For all field* in field**: |
| - $disjoint_(`name, $concatopt_(`name, [?(field*)])) is true. |
| - the name sequence sequence [?(field*)*] is I.FIELDS. |
| |
| Context_ok |
| - the context C is valid if: |
| - C is { TYPES: dt^n; TAGS: jt*; GLOBALS: gt*; MEMS: mt*; TABLES: tt*; FUNCS: dt_F*; DATAS: ok*; ELEMS: et*; LOCALS: lct*; LABELS: [rt*]; RETURN: ?(rt'?); REFS: x*; RECS: st^m }. |
| - the context C_0 is { TYPES: dt^n; RETURN: ?() }. |
| - For all dt in dt*: |
| - Under the context { TYPES: dt^n[0 : i]; RETURN: ?() }, the defined type dt is valid. |
| - For all st in st*: |
| - Under the context { TYPES: dt^n; RETURN: ?(); RECS: st^m }, the sub type st is valid for (OK i). |
| - For all jt in jt*: |
| - Under the context C_0, the tag type jt is valid. |
| - For all gt in gt*: |
| - Under the context C_0, the global type gt is valid. |
| - For all mt in mt*: |
| - Under the context C_0, the memory type mt is valid. |
| - For all tt in tt*: |
| - Under the context C_0, the table type tt is valid. |
| - For all dt_F in dt_F*: |
| - Under the context C_0, the defined type dt_F is valid. |
| - The :ref:`expansion <aux-expand-deftype>` of dt_F is (FUNC [t_1] -> [t_2]). |
| - For all et in et*: |
| - Under the context C_0, the reference type et is valid. |
| - For all lct in lct*: |
| - Under the context C_0, the local type lct is valid. |
| - For all rt in rt*: |
| - Under the context C_0, the result type [rt] is valid. |
| - If rt' is defined, then: |
| - Under the context C_0, the result type [rt'] is valid. |
| - For all x in x*: |
| - |dt_F*| is greater than x. |
| |
| Localval_ok |
| - the value val? is valid with the local type (init t) if: |
| - Either: |
| - val? is ?(val'). |
| - the initialization status init is SET. |
| - the value val' is valid with the value type t. |
| - Or: |
| - val? is ?(). |
| - init is UNSET. |
| - t is BOT. |
| |
| Localval_ok/set |
| - the value ?(val) is valid with the local type (SET t) if: |
| - the value val is valid with the value type t. |
| |
| Localval_ok/unset |
| - the value ?() is valid with the local type (UNSET BOT). |
| |
| Datainst_ok |
| - the data instance { BYTES: b* } is valid with the data type OK. |
| |
| Eleminst_ok |
| - the element instance { TYPE: rt; REFS: ref* } is valid with the element type rt if: |
| - Under the context { RETURN: ?() }, rt is valid. |
| - For all ref in ref*: |
| - the reference value ref is valid with rt. |
| |
| Exportinst_ok |
| - the export instance { NAME: nm; ADDR: xa } is valid if: |
| - the external address xa is valid with the external type xt. |
| |
| Moduleinst_ok |
| - the module instance { TYPES: deftype*; TAGS: tagaddr*; GLOBALS: globaladdr*; MEMS: memaddr*; TABLES: tableaddr*; FUNCS: funcaddr*; DATAS: dataaddr*; ELEMS: elemaddr*; EXPORTS: exportinst* } is valid with the context { TYPES: deftype*; TAGS: tagtype*; GLOBALS: globaltype*; MEMS: memtype*; TABLES: tabletype*; FUNCS: deftype_F*; DATAS: datatype*; ELEMS: elemtype*; RETURN: ?(); REFS: i^(i<|funcaddr*|); RECS: subtype* } if: |
| - For all deftype in deftype*: |
| - Under the context { RETURN: ?() }, the defined type deftype is valid. |
| - For all tagaddr in tagaddr*, and corresponding tagtype in tagtype*: |
| - the external address (TAG tagaddr) is valid with the external type (TAG tagtype). |
| - For all globaladdr in globaladdr*, and corresponding globaltype in globaltype*: |
| - the external address (GLOBAL globaladdr) is valid with the external type (GLOBAL globaltype). |
| - For all deftype_F in deftype_F*, and corresponding funcaddr in funcaddr*: |
| - the external address (FUNC funcaddr) is valid with the external type (FUNC deftype_F). |
| - For all memaddr in memaddr*, and corresponding memtype in memtype*: |
| - the external address (MEM memaddr) is valid with the external type (MEM memtype). |
| - For all tableaddr in tableaddr*, and corresponding tabletype in tabletype*: |
| - the external address (TABLE tableaddr) is valid with the external type (TABLE tabletype). |
| - For all dataaddr in dataaddr*: |
| - the data instance s.DATAS[dataaddr] exists. |
| - For all dataaddr in dataaddr*, and corresponding datatype in datatype*: |
| - s.DATAS[dataaddr] is valid with the data type datatype. |
| - For all elemaddr in elemaddr*: |
| - the element instance s.ELEMS[elemaddr] exists. |
| - For all elemaddr in elemaddr*, and corresponding elemtype in elemtype*: |
| - s.ELEMS[elemaddr] is valid with the element type elemtype. |
| - For all exportinst in exportinst*: |
| - the export instance exportinst is valid. |
| - $disjoint_(`name, exportinst.NAME*) is true. |
| - |(TAG tagaddr)* :: (GLOBAL globaladdr)* :: (MEM memaddr)* :: (TABLE tableaddr)* :: (FUNC funcaddr)*| is greater than 0. |
| - For all exportinst in exportinst*: |
| - exportinst.ADDR is contained in (TAG tagaddr)* :: (GLOBAL globaladdr)* :: (MEM memaddr)* :: (TABLE tableaddr)* :: (FUNC funcaddr)*. |
| |
| Frame_ok |
| - the frame { LOCALS: val?*; MODULE: moduleinst } is valid with the context C with .LOCALS appended by lct* if: |
| - the module instance moduleinst is valid with the context C. |
| - For all lct in lct*, and corresponding val? in val?*: |
| - the value val? is valid with the local type lct. |
| |
| Instr_ok2 |
| - instr is valid with valtype* ->_ localidx* valtype'* if: |
| - Either: |
| - the instruction instr is valid with the instruction type valtype* ->_ localidx* valtype'*. |
| - Or: |
| - instr is ref. |
| - the value type sequence valtype* is []. |
| - the local index sequence localidx* is []. |
| - the value type sequence valtype'* is [rt]. |
| - the reference value ref is valid with the reference type rt. |
| - Or: |
| - instr is (LABEL_ n { instr'* } instr''*). |
| - valtype* is []. |
| - localidx* is []. |
| - instr'* is valid with t'^n ->_ x'* valtype'*. |
| - instr''* is valid with [] ->_ x* valtype'*. |
| - Or: |
| - instr is (FRAME_ n { f } instr''*). |
| - valtype* is []. |
| - localidx* is []. |
| - the frame f is valid with the context C'. |
| - instr''* is valid with valtype'^n. |
| - Or: |
| - instr is (HANDLER_ n { catch* } instr''*). |
| - localidx* is []. |
| - For all catch in catch*: |
| - the catch clause catch is valid. |
| - instr''* is valid with valtype* ->_ x* valtype'*. |
| - Or: |
| - instr is TRAP. |
| - localidx* is []. |
| - the instruction type valtype* -> valtype'* is valid. |
| |
| Instr_ok2/plain |
| - instr is valid with t_1* ->_ x* t_2* if: |
| - the instruction instr is valid with the instruction type t_1* ->_ x* t_2*. |
| |
| Instr_ok2/ref |
| - ref is valid with [] -> [rt] if: |
| - the reference value ref is valid with the reference type rt. |
| |
| Instr_ok2/label |
| - (LABEL_ n { instr'* } instr*) is valid with [] -> t* if: |
| - instr'* is valid with t'^n ->_ x'* t*. |
| - instr* is valid with [] ->_ x* t*. |
| |
| Instr_ok2/frame |
| - (FRAME_ n { f } instr*) is valid with [] -> t^n if: |
| - the frame f is valid with the context C'. |
| - instr* is valid with t^n. |
| |
| Instr_ok2/handler |
| - (HANDLER_ n { catch* } instr*) is valid with t_1* -> t_2* if: |
| - For all catch in catch*: |
| - the catch clause catch is valid. |
| - instr* is valid with t_1* ->_ x* t_2*. |
| |
| Instr_ok2/trap |
| - TRAP is valid with t_1* -> t_2* if: |
| - the instruction type t_1* -> t_2* is valid. |
| |
| Instrs_ok2 |
| - instr* is valid with it if: |
| - Either: |
| - the instruction sequence instr* is []. |
| - the instruction type it is [] -> []. |
| - Or: |
| - instr* is [instr_1] :: instr_2*. |
| - it is t_1* ->_ x_1* :: x_2* t_3*. |
| - instr_1 is valid with t_1* ->_ x_1* t_2*. |
| - For all x_1 in x_1*: |
| - the local C.LOCALS[x_1] exists. |
| - C.LOCALS[x_1] is (init t). |
| - instr_2* is valid with t_2* ->_ x_2* t_3*. |
| - Or: |
| - instr* is valid with it''. |
| - the instruction type it'' matches it. |
| - it is valid. |
| - Or: |
| - it is t* :: t_1* ->_ x* t* :: t_2*. |
| - instr* is valid with t_1* ->_ x* t_2*. |
| - the result type t* is valid. |
| |
| Instrs_ok2/empty |
| - [] is valid with [] -> []. |
| |
| Instrs_ok2/seq |
| - [instr_1] :: instr_2* is valid with t_1* ->_ x_1* :: x_2* t_3* if: |
| - instr_1 is valid with t_1* ->_ x_1* t_2*. |
| - For all x_1 in x_1*: |
| - the local C.LOCALS[x_1] exists. |
| - C.LOCALS[x_1] is (init t). |
| - t* is the concatenation of all such t. |
| - instr_2* is valid with t_2* ->_ x_2* t_3*. |
| |
| Instrs_ok2/sub |
| - instr* is valid with it if: |
| - instr* is valid with it'. |
| - the instruction type it' matches the instruction type it. |
| - it is valid. |
| |
| Instrs_ok2/frame |
| - instr* is valid with t* :: t_1* ->_ x* t* :: t_2* if: |
| - instr* is valid with t_1* ->_ x* t_2*. |
| - the result type t* is valid. |
| |
| Expr_ok2 |
| - instr* is valid with t* if: |
| - instr* is valid with [] -> t*. |
| |
| Taginst_ok |
| - the tag instance { TYPE: jt } is valid with the tag type jt if: |
| - Under the context { RETURN: ?() }, jt is valid. |
| |
| Globalinst_ok |
| - the global instance { TYPE: (mut? t); VALUE: val } is valid with the global type (mut? t) if: |
| - Under the context { RETURN: ?() }, (mut? t) is valid. |
| - the value val is valid with the value type t. |
| |
| Meminst_ok |
| - the memory instance { TYPE: at ([ n .. ?(m) ]) PAGE; BYTES: b* } is valid with the memory type at ([ n .. ?(m) ]) PAGE if: |
| - Under the context { RETURN: ?() }, at ([ n .. ?(m) ]) PAGE is valid. |
| - |b*| is (n * (64 * $Ki())). |
| |
| Tableinst_ok |
| - the table instance { TYPE: (at ([ n .. ?(m) ]) rt); REFS: ref* } is valid with the table type (at ([ n .. ?(m) ]) rt) if: |
| - Under the context { RETURN: ?() }, (at ([ n .. ?(m) ]) rt) is valid. |
| - |ref*| is n. |
| - For all ref in ref*: |
| - the reference value ref is valid with the reference type rt. |
| |
| Funcinst_ok |
| - the function instance { TYPE: dt; MODULE: moduleinst; CODE: func } is valid with the defined type dt if: |
| - Under the context { RETURN: ?() }, dt is valid. |
| - the module instance moduleinst is valid with the context C. |
| - the function func is valid with the defined type dt'. |
| - dt' matches dt. |
| |
| Structinst_ok |
| - the structure instance { TYPE: dt; FIELDS: fv* } is valid if: |
| - The :ref:`expansion <aux-expand-deftype>` of dt is (STRUCT (mut? zt)*). |
| - For all fv in fv*, and corresponding zt in zt*: |
| - the field value fv is valid with the storage type zt. |
| |
| Arrayinst_ok |
| - the array instance { TYPE: dt; FIELDS: fv* } is valid if: |
| - The :ref:`expansion <aux-expand-deftype>` of dt is (ARRAY (mut? zt)). |
| - For all fv in fv*: |
| - the field value fv is valid with the storage type zt. |
| |
| Exninst_ok |
| - the exception instance { TAG: ta; FIELDS: val* } is valid if: |
| - the tag instance s.TAGS[ta] exists. |
| - the tag type dt is s.TAGS[ta].TYPE. |
| - The :ref:`expansion <aux-expand-deftype>` of dt is (FUNC t* -> []). |
| - For all t in t*, and corresponding val in val*: |
| - the value val is valid with the value type t. |
| |
| Store_ok |
| - the store s is valid if: |
| - For all : |
| - the tag instance taginst is valid with the tag type tagtype. |
| - taginst* is the concatenation of all such taginst. |
| - For all : |
| - the global instance globalinst is valid with the global type globaltype. |
| - globalinst* is the concatenation of all such globalinst. |
| - For all : |
| - the memory instance meminst is valid with the memory type memtype. |
| - meminst* is the concatenation of all such meminst. |
| - For all : |
| - the table instance tableinst is valid with the table type tabletype. |
| - tableinst* is the concatenation of all such tableinst. |
| - For all : |
| - the function instance funcinst is valid with the defined type deftype. |
| - funcinst* is the concatenation of all such funcinst. |
| - For all : |
| - the data instance datainst is valid with the data type datatype. |
| - datainst* is the concatenation of all such datainst. |
| - For all : |
| - the element instance eleminst is valid with the element type elemtype. |
| - eleminst* is the concatenation of all such eleminst. |
| - For all structinst in structinst*: |
| - the structure instance structinst is valid. |
| - For all arrayinst in arrayinst*: |
| - the array instance arrayinst is valid. |
| - For all exninst in exninst*: |
| - the exception instance exninst is valid. |
| - For all : |
| - (REF.STRUCT_ADDR a) is not immutably reachable from (REF.STRUCT_ADDR a). |
| - (REF.ARRAY_ADDR a) is not immutably reachable from (REF.ARRAY_ADDR a). |
| - (REF.EXN_ADDR a) is not immutably reachable from (REF.EXN_ADDR a). |
| - s is { TAGS: taginst*; GLOBALS: globalinst*; MEMS: meminst*; TABLES: tableinst*; FUNCS: funcinst*; DATAS: datainst*; ELEMS: eleminst*; STRUCTS: structinst*; ARRAYS: arrayinst*; EXNS: exninst* }. |
| |
| State_ok |
| - the state (s, f) is valid with the context C if: |
| - the store s is valid. |
| - the frame f is valid with C. |
| |
| Config_ok |
| - the configuration (s, f) ; instr* is valid with the result type t* if: |
| - the state (s, f) is valid with the context C. |
| - instr* is valid with t*. |
| |
| NotationTypingInstrScheme |
| - the instruction sequence [instr] is valid with the instruction type valtype* -> valtype'* if: |
| - Either: |
| - the instruction instr is (BINOP I32 ADD). |
| - the value type sequence valtype* is [I32, I32]. |
| - the value type sequence valtype'* is [I32]. |
| - Or: |
| - instr is (GLOBAL.GET x). |
| - valtype* is []. |
| - valtype'* is [t]. |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?(mut) t). |
| - Or: |
| - instr is (BLOCK blocktype instr'*). |
| - the block type blocktype is valid as valtype* -> valtype'*. |
| - the context C' is the context C with .LABELS prepended by [valtype'*]. |
| - Under the context C', the instruction sequence instr'* is valid with valtype* -> valtype'*. |
| |
| NotationTypingInstrScheme/i32.add |
| - the instruction sequence [(BINOP I32 ADD)] is valid with the instruction type [I32, I32] -> [I32]. |
| |
| NotationTypingInstrScheme/global.get |
| - the instruction sequence [(GLOBAL.GET x)] is valid with the instruction type [] -> [t] if: |
| - the global C.GLOBALS[x] exists. |
| - C.GLOBALS[x] is (?(mut) t). |
| |
| NotationTypingInstrScheme/block |
| - the instruction sequence [(BLOCK blocktype instr*)] is valid with the instruction type t_1* -> t_2* if: |
| - the block type blocktype is valid as t_1* -> t_2*. |
| - the context C' is the context C with .LABELS prepended by [t_2*]. |
| - Under the context C', the instruction sequence instr* is valid with t_1* -> t_2*. |
| |
| Step_pure/br-label-* l |
| 1. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| 2. Let (LABEL_ n { instr'* }) be the topmost LABEL_. |
| 3. If (l = 0), then: |
| a. Assert: Due to validation, there are at least n values on the top of the stack. |
| b. Pop the values val^n from the stack. |
| c. Pop all values val'* from the top of the stack. |
| d. Pop the label (LABEL_ _ { _ }) from the stack. |
| e. Push the values val^n to the stack. |
| f. Execute the sequence instr'*. |
| 4. Else: |
| a. Pop all values val* from the top of the stack. |
| b. Pop the label (LABEL_ _ { _ }) from the stack. |
| c. Push the values val* to the stack. |
| d. Execute the instruction (BR (l - 1)). |
| |
| Step_read/return_call_ref-frame-* yy |
| 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 val'' from the stack. |
| 4. Assert: Due to validation, the first non-value entry of the stack is a FRAME_. |
| 5. If (val'' = REF.NULL_ADDR), then: |
| a. Trap. |
| 6. Assert: Due to validation, val'' is some REF.FUNC_ADDR. |
| 7. Let (REF.FUNC_ADDR a) be val''. |
| 8. Assert: Due to validation, (a < |$funcinst(z)|). |
| 9. Assert: Due to validation, $Expand($funcinst(z)[a].TYPE) is some ->. |
| 10. Let (FUNC t_1^n -> t_2^m) be $Expand($funcinst(z)[a].TYPE). |
| 11. Assert: Due to validation, there are at least n values on the top of the stack. |
| 12. Pop the values val^n from the stack. |
| 13. Pop all values val'* from the top of the stack. |
| 14. Pop the frame (FRAME_ _ { _ }) from the stack. |
| 15. Push the values val^n to the stack. |
| 16. Push the value (REF.FUNC_ADDR a) to the stack. |
| 17. Execute the instruction (CALL_REF yy). |
| |
| Step_read/throw_ref-instrs-* |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value (REF.EXN_ADDR a) from the stack. |
| 3. Pop all values val* from the top of the stack. |
| 4. Assert: Due to validation, (val* =/= []). |
| 5. Push the value (REF.EXN_ADDR a) to the stack. |
| 6. Execute the instruction THROW_REF. |
| |
| Step_read/throw_ref-handler-* |
| 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 (REF.EXN_ADDR a) from the stack. |
| 4. Assert: Due to validation, the first non-value entry of the stack is a HANDLER_. |
| 5. Let (HANDLER_ n { catch''* }) be the topmost HANDLER_. |
| 6. If (catch''* = []), then: |
| a. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| b. Push the value (REF.EXN_ADDR a) to the stack. |
| c. Execute the instruction THROW_REF. |
| 7. Else if (a >= |$exninst(z)|), then: |
| a. Let [catch_0] :: catch'* be catch''*. |
| b. If catch_0 is some CATCH_ALL, then: |
| 1) Let (CATCH_ALL l) be catch_0. |
| 2) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3) Execute the instruction (BR l). |
| c. Else if catch_0 is not CATCH_ALL_REF, then: |
| 1) Let [catch] :: catch'* be catch''*. |
| 2) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3) Push the handler (HANDLER_ n { catch'* }) to the stack. |
| 4) Push the value (REF.EXN_ADDR a) to the stack. |
| 5) Execute the instruction THROW_REF. |
| d. Else: |
| 1) Let (CATCH_ALL_REF l) be catch_0. |
| 2) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3) Push the value (REF.EXN_ADDR a) to the stack. |
| 4) Execute the instruction (BR l). |
| 8. Else: |
| a. Let val* be $exninst(z)[a].FIELDS. |
| b. Let [catch_0] :: catch'* be catch''*. |
| c. If catch_0 is some CATCH, then: |
| 1) Let (CATCH x l) be catch_0. |
| 2) If ((x < |$tagaddr(z)|) /\ ($exninst(z)[a].TAG = $tagaddr(z)[x])), then: |
| a) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| b) Push the values val* to the stack. |
| c) Execute the instruction (BR l). |
| 3) Else: |
| a) Let [catch] :: catch'* be catch''*. |
| b) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| c) Push the handler (HANDLER_ n { catch'* }) to the stack. |
| d) Push the value (REF.EXN_ADDR a) to the stack. |
| e) Execute the instruction THROW_REF. |
| d. Else if catch_0 is some CATCH_REF, then: |
| 1) Let (CATCH_REF x l) be catch_0. |
| 2) If ((x >= |$tagaddr(z)|) \/ ($exninst(z)[a].TAG =/= $tagaddr(z)[x])), then: |
| a) Let [catch] :: catch'* be catch''*. |
| b) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| c) Push the handler (HANDLER_ n { catch'* }) to the stack. |
| d) Push the value (REF.EXN_ADDR a) to the stack. |
| e) Execute the instruction THROW_REF. |
| 3) Else: |
| a) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| b) Push the values val* to the stack. |
| c) Push the value (REF.EXN_ADDR a) to the stack. |
| d) Execute the instruction (BR l). |
| e. Else if catch_0 is some CATCH_ALL, then: |
| 1) Let (CATCH_ALL l) be catch_0. |
| 2) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3) Execute the instruction (BR l). |
| f. Else if catch_0 is not CATCH_ALL_REF, then: |
| 1) Let [catch] :: catch'* be catch''*. |
| 2) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3) Push the handler (HANDLER_ n { catch'* }) to the stack. |
| 4) Push the value (REF.EXN_ADDR a) to the stack. |
| 5) Execute the instruction THROW_REF. |
| g. Else: |
| 1) Let (CATCH_ALL_REF l) be catch_0. |
| 2) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3) Push the value (REF.EXN_ADDR a) to the stack. |
| 4) Execute the instruction (BR l). |
| |
| Step_read/table.copy-oob-* x_1 x_2 |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at_2.CONST i_2) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at_1.CONST i_1) from the stack. |
| 8. If ((i_1 + n) > |$table(z, x_1).REFS|), then: |
| a. Trap. |
| 9. If ((i_2 + n) > |$table(z, x_2).REFS|), then: |
| a. Trap. |
| |
| Step_read/table.init-oob-* x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST j) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at.CONST i) from the stack. |
| 8. If ((i + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| 9. If ((j + n) > |$elem(z, y).REFS|), then: |
| a. Trap. |
| |
| Step_read/load-num-* nt ?() x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 5. Let c be $nbytes__1^-1(nt, $mem(z, x).BYTES[(i + ao.OFFSET) : ($size(nt) / 8)]). |
| 6. Push the value (nt.CONST c) to the stack. |
| |
| Step_read/load-pack-* Inn ?(n _ sx) x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 5. Let c be $ibytes__1^-1(n, $mem(z, x).BYTES[(i + ao.OFFSET) : (n / 8)]). |
| 6. Push the value (Inn.CONST $extend__(n, $size(Inn), sx, c)) to the stack. |
| |
| Step_read/vload-pack-* V128 ?((SHAPE K X M _ sx)) x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + ((K * M) / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 5. Let j^M be $ibytes__1^-1(K, $mem(z, x).BYTES[((i + ao.OFFSET) + ((k * K) / 8)) : (K / 8)])^(k<M). |
| 6. Let Jnn be $jsizenn^-1((K * 2)). |
| 7. Let c be $inv_lanes_(Jnn X M, $extend__(K, $jsizenn(Jnn), sx, j)^M). |
| 8. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/vload-splat-* V128 ?((SPLAT N)) x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 5. Let M be (128 / N). |
| 6. Let Jnn be $jsize^-1(N). |
| 7. Let j be $ibytes__1^-1(N, $mem(z, x).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 8. Let c be $inv_lanes_(Jnn X M, j^M). |
| 9. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/vload-zero-* V128 ?((ZERO N)) x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 5. Let j be $ibytes__1^-1(N, $mem(z, x).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 6. Let c be $extend__(N, 128, U, j). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/memory.copy-oob-* x_1 x_2 |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at_2.CONST i_2) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at_1.CONST i_1) from the stack. |
| 8. If ((i_1 + n) > |$mem(z, x_1).BYTES|), then: |
| a. Trap. |
| 9. If ((i_2 + n) > |$mem(z, x_2).BYTES|), then: |
| a. Trap. |
| |
| Step_read/memory.init-oob-* x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST j) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at.CONST i) from the stack. |
| 8. If ((i + n) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 9. If ((j + n) > |$data(z, y).BYTES|), then: |
| a. Trap. |
| |
| Step/store-num-* nt ?() x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 3. Pop the value (numtype_0.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $nbytes_(nt, c). |
| 8. Perform $with_mem(z, x, (i + ao.OFFSET), ($size(nt) / 8), b*). |
| |
| Step/store-pack-* Inn ?(n) x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type Inn is on the top of the stack. |
| 3. Pop the value (numtype_0.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)). |
| 8. Perform $with_mem(z, x, (i + ao.OFFSET), (n / 8), b*). |
| |
| Step_pure/unreachable |
| 1. Trap. |
| |
| Step_pure/nop |
| 1. Do nothing. |
| |
| Step_pure/drop |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| |
| Step_pure/select t*? |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. Assert: Due to validation, a value is on the top of the stack. |
| 4. Pop the value val_2 from the stack. |
| 5. Assert: Due to validation, a value is on the top of the stack. |
| 6. Pop the value val_1 from the stack. |
| 7. If (c =/= 0), then: |
| a. Push the value val_1 to the stack. |
| 8. Else: |
| a. Push the value val_2 to the stack. |
| |
| Step_pure/if bt instr_1* instr_2* |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. If (c =/= 0), then: |
| a. Execute the instruction (BLOCK bt instr_1*). |
| 4. Else: |
| a. Execute the instruction (BLOCK bt instr_2*). |
| |
| Step_pure/label |
| 1. Pop all values val* from the top of the stack. |
| 2. Assert: Due to validation, the first non-value entry of the stack is a LABEL_. |
| 3. Pop the label (LABEL_ _ { _ }) from the stack. |
| 4. Push the values val* to the stack. |
| |
| Step_pure/br l |
| 1. If the first non-value entry of the stack is a LABEL_, then: |
| a. Let (LABEL_ n { instr'* }) be the topmost LABEL_. |
| b. 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 val^n from the stack. |
| 3) Pop all values val'* from the top of the stack. |
| 4) Pop the label (LABEL_ _ { _ }) from the stack. |
| 5) Push the values val^n to the stack. |
| 6) Execute the sequence instr'*. |
| c. Else: |
| 1) Pop all values val* from the top of the stack. |
| 2) Pop the label (LABEL_ _ { _ }) from the stack. |
| 3) Push the values val* to the stack. |
| 4) Execute the instruction (BR (l - 1)). |
| 2. Else: |
| a. Assert: Due to validation, the first non-value entry of the stack is a HANDLER_. |
| b. Pop all values val* from the top of the stack. |
| c. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| d. Push the values val* to the stack. |
| e. Execute the instruction (BR l). |
| |
| Step_pure/br_if l |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST c) from the stack. |
| 3. If (c =/= 0), then: |
| a. Execute the instruction (BR l). |
| 4. Else: |
| a. Do nothing. |
| |
| Step_pure/br_table l* l' |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST i) from the stack. |
| 3. If (i < |l*|), then: |
| a. Execute the instruction (BR l*[i]). |
| 4. Else: |
| a. Execute the instruction (BR l'). |
| |
| Step_pure/br_on_null l |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| 3. If (val = REF.NULL_ADDR), then: |
| a. Execute the instruction (BR l). |
| 4. Else: |
| a. Push the value val to the stack. |
| |
| Step_pure/br_on_non_null l |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| 3. If (val = REF.NULL_ADDR), then: |
| a. Do nothing. |
| 4. Else: |
| a. Push the value val to the stack. |
| b. Execute the instruction (BR l). |
| |
| Step_pure/call_indirect x yy |
| 1. Execute the instruction (TABLE.GET x). |
| 2. Execute the instruction (REF.CAST (REF ?(NULL) yy)). |
| 3. Execute the instruction (CALL_REF yy). |
| |
| Step_pure/return_call_indirect x yy |
| 1. Execute the instruction (TABLE.GET x). |
| 2. Execute the instruction (REF.CAST (REF ?(NULL) yy)). |
| 3. Execute the instruction (RETURN_CALL_REF yy). |
| |
| Step_pure/frame |
| 1. Let (FRAME_ n { f }) be the topmost FRAME_. |
| 2. Assert: Due to validation, there are at least n values on the top of the stack. |
| 3. Assert: Due to validation, there are at least n values on the top of the stack. |
| 4. Pop the values val^n from the stack. |
| 5. Assert: Due to validation, the first non-value entry of the stack is a FRAME_. |
| 6. Pop the frame (FRAME_ _ { _ }) from the stack. |
| 7. Push the values val^n to the stack. |
| |
| Step_pure/return |
| 1. If the first non-value entry of the stack is a FRAME_, then: |
| a. Let (FRAME_ n { f }) be the topmost FRAME_. |
| b. Assert: Due to validation, there are at least n values on the top of the stack. |
| c. Pop the values val^n from the stack. |
| d. Pop all values val'* from the top of the stack. |
| e. Pop the frame (FRAME_ _ { _ }) from the stack. |
| f. Push the values val^n to the stack. |
| 2. Else if the first non-value entry of the stack is a LABEL_, then: |
| a. Pop all values val* from the top of the stack. |
| b. Pop the label (LABEL_ _ { _ }) from the stack. |
| c. Push the values val* to the stack. |
| d. Execute the instruction RETURN. |
| 3. Else: |
| a. Assert: Due to validation, the first non-value entry of the stack is a HANDLER_. |
| b. Pop all values val* from the top of the stack. |
| c. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| d. Push the values val* to the stack. |
| e. Execute the instruction RETURN. |
| |
| Step_pure/handler |
| 1. Pop all values val* from the top of the stack. |
| 2. Assert: Due to validation, the first non-value entry of the stack is a HANDLER_. |
| 3. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 4. Push the values val* to the stack. |
| |
| Step_pure/local.tee x |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| 3. Push the value val to the stack. |
| 4. Push the value val to the stack. |
| 5. Execute the instruction (LOCAL.SET x). |
| |
| Step_pure/ref.i31 |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST i) from the stack. |
| 3. Push the value (REF.I31_NUM $wrap__(32, 31, i)) to the stack. |
| |
| Step_pure/ref.is_null |
| 1. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 2. Pop the value ref from the stack. |
| 3. If (ref = REF.NULL_ADDR), then: |
| a. Push the value (I32.CONST 1) to the stack. |
| 4. Else: |
| a. Push the value (I32.CONST 0) to the stack. |
| |
| Step_pure/ref.as_non_null |
| 1. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 2. Pop the value ref from the stack. |
| 3. If (ref = REF.NULL_ADDR), then: |
| a. Trap. |
| 4. Push the value ref to the stack. |
| |
| Step_pure/ref.eq |
| 1. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 2. Pop the value ref_2 from the stack. |
| 3. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 4. Pop the value ref_1 from the stack. |
| 5. If ((ref_1 = REF.NULL_ADDR) /\ (ref_2 = REF.NULL_ADDR)), then: |
| a. Push the value (I32.CONST 1) to the stack. |
| 6. Else if (ref_1 = ref_2), then: |
| a. Push the value (I32.CONST 1) to the stack. |
| 7. Else: |
| a. Push the value (I32.CONST 0) to the stack. |
| |
| Step_pure/i31.get sx |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| 3. If (val = REF.NULL_ADDR), then: |
| a. Trap. |
| 4. Assert: Due to validation, val is some REF.I31_NUM. |
| 5. Let (REF.I31_NUM i) be val. |
| 6. Push the value (I32.CONST $extend__(31, 32, sx, i)) to the stack. |
| |
| Step_pure/array.new x |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST n) from the stack. |
| 3. Assert: Due to validation, a value is on the top of the stack. |
| 4. Pop the value val from the stack. |
| 5. Push the values val^n to the stack. |
| 6. Execute the instruction (ARRAY.NEW_FIXED x n). |
| |
| Step_pure/extern.convert_any |
| 1. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 2. Pop the value ref from the stack. |
| 3. If (ref = REF.NULL_ADDR), then: |
| a. Push the value REF.NULL_ADDR to the stack. |
| 4. Else: |
| a. Push the value (REF.EXTERN ref) to the stack. |
| |
| Step_pure/any.convert_extern |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value val from the stack. |
| 3. If (val = REF.NULL_ADDR), then: |
| a. Push the value REF.NULL_ADDR to the stack. |
| 4. If val is some REF.EXTERN, then: |
| a. Let (REF.EXTERN ref) be val. |
| b. Push the value ref to the stack. |
| |
| Step_pure/unop nt unop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. If (|$unop_(nt, unop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $unop_(nt, unop, c_1). |
| 5. Push the value (nt.CONST c) to the stack. |
| |
| Step_pure/binop nt binop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 4. Pop the value (numtype_0.CONST c_1) from the stack. |
| 5. If (|$binop_(nt, binop, c_1, c_2)| <= 0), then: |
| a. Trap. |
| 6. Let c be an element of $binop_(nt, binop, c_1, c_2). |
| 7. Push the value (nt.CONST c) to the stack. |
| |
| Step_pure/testop nt testop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. Let c be $testop_(nt, testop, c_1). |
| 4. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/relop nt relop |
| 1. Assert: Due to validation, a value of value type nt is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 4. Pop the value (numtype_0.CONST c_1) from the stack. |
| 5. Let c be $relop_(nt, relop, c_1, c_2). |
| 6. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/cvtop nt_2 nt_1 cvtop |
| 1. Assert: Due to validation, a value of value type nt_1 is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. If (|$cvtop__(nt_1, nt_2, cvtop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $cvtop__(nt_1, nt_2, cvtop, c_1). |
| 5. Push the value (nt_2.CONST c) to the stack. |
| |
| Step_pure/vvunop V128 vvunop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Assert: Due to validation, (|$vvunop_(V128, vvunop, c_1)| > 0). |
| 4. Let c be an element of $vvunop_(V128, vvunop, c_1). |
| 5. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vvbinop V128 vvbinop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Assert: Due to validation, (|$vvbinop_(V128, vvbinop, c_1, c_2)| > 0). |
| 6. Let c be an element of $vvbinop_(V128, vvbinop, c_1, c_2). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vvternop V128 vvternop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_3) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_2) from the stack. |
| 5. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 6. Pop the value (V128.CONST c_1) from the stack. |
| 7. Assert: Due to validation, (|$vvternop_(V128, vvternop, c_1, c_2, c_3)| > 0). |
| 8. Let c be an element of $vvternop_(V128, vvternop, c_1, c_2, c_3). |
| 9. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vvtestop V128 ANY_TRUE |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let c be $inez_($vsize(V128), c_1). |
| 4. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/vunop sh vunop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. If (|$vunop_(sh, vunop, c_1)| <= 0), then: |
| a. Trap. |
| 4. Let c be an element of $vunop_(sh, vunop, c_1). |
| 5. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vbinop sh vbinop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. If (|$vbinop_(sh, vbinop, c_1, c_2)| <= 0), then: |
| a. Trap. |
| 6. Let c be an element of $vbinop_(sh, vbinop, c_1, c_2). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vternop sh vternop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_3) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_2) from the stack. |
| 5. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 6. Pop the value (V128.CONST c_1) from the stack. |
| 7. If (|$vternop_(sh, vternop, c_1, c_2, c_3)| <= 0), then: |
| a. Trap. |
| 8. Let c be an element of $vternop_(sh, vternop, c_1, c_2, c_3). |
| 9. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vtestop Jnn X M ALL_TRUE |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let i* be $lanes_(Jnn X M, c_1). |
| 4. Let c be $prod($inez_($jsizenn(Jnn), i)*). |
| 5. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/vrelop sh vrelop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vrelop_(sh, vrelop, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vshiftop sh vshiftop |
| 1. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 2. Pop the value (I32.CONST i) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vshiftop_(sh, vshiftop, c_1, i). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vbitmask sh |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let c be $vbitmaskop_(sh, c_1). |
| 4. Push the value (I32.CONST c) to the stack. |
| |
| Step_pure/vswizzlop sh swizzlop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vswizzlop_(sh, swizzlop, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vshuffle sh i* |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vshufflop_(sh, i*, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vsplat Lnn X M |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_1) from the stack. |
| 3. Assert: Due to validation, (numtype_0 = $lunpack(Lnn)). |
| 4. Let c be $inv_lanes_(Lnn X M, $lpacknum_(Lnn, c_1)^M). |
| 5. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vextract_lane lanetype X M sx'? i |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. If sx'? is not defined, then: |
| a. Assert: Due to validation, lanetype is numtype. |
| b. Assert: Due to validation, (i < |$lanes_(lanetype X M, c_1)|). |
| c. Let c_2 be $lanes_(lanetype X M, c_1)[i]. |
| d. Push the value (lanetype.CONST c_2) to the stack. |
| 4. Else: |
| a. Assert: Due to validation, lanetype is packtype. |
| b. Let ?(sx) be sx'?. |
| c. Assert: Due to validation, (i < |$lanes_(lanetype X M, c_1)|). |
| d. Let c_2 be $extend__($psize(lanetype), 32, sx, $lanes_(lanetype X M, c_1)[i]). |
| e. Push the value (I32.CONST c_2) to the stack. |
| |
| Step_pure/vreplace_lane Lnn X M i |
| 1. Assert: Due to validation, a value is on the top of the stack. |
| 2. Pop the value (numtype_0.CONST c_2) from the stack. |
| 3. Assert: Due to validation, (numtype_0 = $lunpack(Lnn)). |
| 4. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 5. Pop the value (V128.CONST c_1) from the stack. |
| 6. Let c be $inv_lanes_(Lnn X M, $lanes_(Lnn X M, c_1) with [i] replaced by $lpacknum_(Lnn, c_2)). |
| 7. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vextunop sh_2 sh_1 vextunop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let c be $vextunop__(sh_1, sh_2, vextunop, c_1). |
| 4. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vextbinop sh_2 sh_1 vextbinop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vextbinop__(sh_1, sh_2, vextbinop, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vextternop sh_2 sh_1 vextternop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_3) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_2) from the stack. |
| 5. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 6. Pop the value (V128.CONST c_1) from the stack. |
| 7. Let c be $vextternop__(sh_1, sh_2, vextternop, c_1, c_2, c_3). |
| 8. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vnarrow sh_2 sh_1 sx |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_2) from the stack. |
| 3. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 4. Pop the value (V128.CONST c_1) from the stack. |
| 5. Let c be $vnarrowop__(sh_1, sh_2, sx, c_1, c_2). |
| 6. Push the value (V128.CONST c) to the stack. |
| |
| Step_pure/vcvtop sh_2 sh_1 vcvtop |
| 1. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 2. Pop the value (V128.CONST c_1) from the stack. |
| 3. Let c be $vcvtop__(sh_1, sh_2, vcvtop, c_1). |
| 4. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/block bt instr* |
| 1. Let z be the current state. |
| 2. Let t_1^m ->_ localidx_0* t_2^n be $blocktype_(z, bt). |
| 3. Assert: Due to validation, (localidx_0* = []). |
| 4. Assert: Due to validation, there are at least m values on the top of the stack. |
| 5. Pop the values val^m from the stack. |
| 6. Enter val^m :: instr* with label (LABEL_ n { [] }). |
| |
| Step_read/loop bt instr* |
| 1. Let z be the current state. |
| 2. Let t_1^m ->_ localidx_0* t_2^n be $blocktype_(z, bt). |
| 3. Assert: Due to validation, (localidx_0* = []). |
| 4. Assert: Due to validation, there are at least m values on the top of the stack. |
| 5. Pop the values val^m from the stack. |
| 6. Enter val^m :: instr* with label (LABEL_ m { [(LOOP bt instr*)] }). |
| |
| Step_read/br_on_cast l rt_1 rt_2 |
| 1. Let (FRAME_ _ { f }) be the topmost FRAME_. |
| 2. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 3. Pop the value ref from the stack. |
| 4. Push the value ref to the stack. |
| 5. If $Ref_ok(ref, $inst_reftype(f.MODULE, rt_2)), then: |
| a. Execute the instruction (BR l). |
| 6. Else: |
| a. Do nothing. |
| |
| Step_read/br_on_cast_fail l rt_1 rt_2 |
| 1. Let (FRAME_ _ { f }) be the topmost FRAME_. |
| 2. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 3. Pop the value ref from the stack. |
| 4. Push the value ref to the stack. |
| 5. If $Ref_ok(ref, $inst_reftype(f.MODULE, rt_2)), then: |
| a. Do nothing. |
| 6. Else: |
| a. Execute the instruction (BR l). |
| |
| Step_read/call x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (x < |$moduleinst(z).FUNCS|). |
| 3. Let a be $moduleinst(z).FUNCS[x]. |
| 4. Assert: Due to validation, (a < |$funcinst(z)|). |
| 5. Push the value (REF.FUNC_ADDR a) to the stack. |
| 6. Execute the instruction (CALL_REF $funcinst(z)[a].TYPE). |
| |
| Step_read/call_ref yy |
| 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 val' from the stack. |
| 4. If (val' = REF.NULL_ADDR), then: |
| a. Trap. |
| 5. Assert: Due to validation, val' is some REF.FUNC_ADDR. |
| 6. Let (REF.FUNC_ADDR a) be val'. |
| 7. Assert: Due to validation, (a < |$funcinst(z)|). |
| 8. Let fi be $funcinst(z)[a]. |
| 9. Assert: Due to validation, fi.CODE is some FUNC. |
| 10. Let (FUNC x local_0* instr*) be fi.CODE. |
| 11. Let t* be []. |
| 12. For each local_0 in local_0*, do: |
| a. Let (LOCAL t) be local_0. |
| b. Append t to the t*. |
| 13. Assert: Due to validation, $Expand(fi.TYPE) is some ->. |
| 14. Let (FUNC t_1^n -> t_2^m) be $Expand(fi.TYPE). |
| 15. Assert: Due to validation, there are at least n values on the top of the stack. |
| 16. Pop the values val^n from the stack. |
| 17. Let f be { LOCALS: ?(val)^n :: $default_(t)*; MODULE: fi.MODULE }. |
| 18. Push the frame (FRAME_ m { f }) to the stack. |
| 19. Enter instr* with label (LABEL_ m { [] }). |
| |
| Step_read/return_call x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (x < |$moduleinst(z).FUNCS|). |
| 3. Let a be $moduleinst(z).FUNCS[x]. |
| 4. Assert: Due to validation, (a < |$funcinst(z)|). |
| 5. Push the value (REF.FUNC_ADDR a) to the stack. |
| 6. Execute the instruction (RETURN_CALL_REF $funcinst(z)[a].TYPE). |
| |
| Step_read/return_call_ref yy |
| 1. Let z be the current state. |
| 2. If the first non-value entry of the stack is a LABEL_, then: |
| a. Pop all values val* from the top of the stack. |
| b. Pop the label (LABEL_ _ { _ }) from the stack. |
| c. Push the values val* to the stack. |
| d. Execute the instruction (RETURN_CALL_REF yy). |
| 3. Else if the first non-value entry of the stack is a HANDLER_, then: |
| a. Pop all values val* from the top of the stack. |
| b. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| c. Push the values val* to the stack. |
| d. Execute the instruction (RETURN_CALL_REF yy). |
| 4. Else: |
| a. Assert: Due to validation, the first non-value entry of the stack is a FRAME_. |
| b. Assert: Due to validation, a value is on the top of the stack. |
| c. Pop the value val'' from the stack. |
| d. If (val'' = REF.NULL_ADDR), then: |
| 1) Trap. |
| e. Assert: Due to validation, val'' is some REF.FUNC_ADDR. |
| f. Let (REF.FUNC_ADDR a) be val''. |
| g. Assert: Due to validation, (a < |$funcinst(z)|). |
| h. Assert: Due to validation, $Expand($funcinst(z)[a].TYPE) is some ->. |
| i. Let (FUNC t_1^n -> t_2^m) be $Expand($funcinst(z)[a].TYPE). |
| j. Assert: Due to validation, there are at least n values on the top of the stack. |
| k. Pop the values val^n from the stack. |
| l. Pop all values val'* from the top of the stack. |
| m. Pop the frame (FRAME_ _ { _ }) from the stack. |
| n. Push the values val^n to the stack. |
| o. Push the value (REF.FUNC_ADDR a) to the stack. |
| p. Execute the instruction (CALL_REF yy). |
| |
| Step_read/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 val' from the stack. |
| 4. If (val' = REF.NULL_ADDR), then: |
| a. Trap. |
| 5. If val' is some REF.EXN_ADDR, then: |
| a. Let (REF.EXN_ADDR a) be val'. |
| b. Pop all values val* from the top of the stack. |
| c. If (val* =/= []), then: |
| 1) Push the value (REF.EXN_ADDR a) to the stack. |
| 2) Execute the instruction THROW_REF. |
| d. Else if the first non-value entry of the stack is a LABEL_, then: |
| 1) Pop the label (LABEL_ _ { _ }) from the stack. |
| 2) Push the value (REF.EXN_ADDR a) to the stack. |
| 3) Execute the instruction THROW_REF. |
| e. Else if the first non-value entry of the stack is a FRAME_, then: |
| 1) Pop the frame (FRAME_ _ { _ }) from the stack. |
| 2) Push the value (REF.EXN_ADDR a) to the stack. |
| 3) Execute the instruction THROW_REF. |
| f. Else if the first non-value entry of the stack is not a HANDLER_, then: |
| 1) Throw the exception val' as a result. |
| g. Else: |
| 1) Let (HANDLER_ n { catch''* }) be the topmost HANDLER_. |
| 2) If (catch''* = []), then: |
| a) Pop the handler (HANDLER_ _ { _ }) from the stack. |
| b) Push the value (REF.EXN_ADDR a) to the stack. |
| c) Execute the instruction THROW_REF. |
| 3) Else if (a >= |$exninst(z)|), then: |
| a) Let [catch_0] :: catch'* be catch''*. |
| b) If catch_0 is some CATCH_ALL, then: |
| 1. Let (CATCH_ALL l) be catch_0. |
| 2. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3. Execute the instruction (BR l). |
| c) Else if catch_0 is not CATCH_ALL_REF, then: |
| 1. Let [catch] :: catch'* be catch''*. |
| 2. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3. Push the handler (HANDLER_ n { catch'* }) to the stack. |
| 4. Push the value (REF.EXN_ADDR a) to the stack. |
| 5. Execute the instruction THROW_REF. |
| d) Else: |
| 1. Let (CATCH_ALL_REF l) be catch_0. |
| 2. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3. Push the value (REF.EXN_ADDR a) to the stack. |
| 4. Execute the instruction (BR l). |
| 4) Else: |
| a) Let val* be $exninst(z)[a].FIELDS. |
| b) Let [catch_0] :: catch'* be catch''*. |
| c) If catch_0 is some CATCH, then: |
| 1. Let (CATCH x l) be catch_0. |
| 2. If ((x < |$tagaddr(z)|) /\ ($exninst(z)[a].TAG = $tagaddr(z)[x])), then: |
| a. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| b. Push the values val* to the stack. |
| c. Execute the instruction (BR l). |
| 3. Else: |
| a. Let [catch] :: catch'* be catch''*. |
| b. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| c. Push the handler (HANDLER_ n { catch'* }) to the stack. |
| d. Push the value (REF.EXN_ADDR a) to the stack. |
| e. Execute the instruction THROW_REF. |
| d) Else if catch_0 is some CATCH_REF, then: |
| 1. Let (CATCH_REF x l) be catch_0. |
| 2. If ((x >= |$tagaddr(z)|) \/ ($exninst(z)[a].TAG =/= $tagaddr(z)[x])), then: |
| a. Let [catch] :: catch'* be catch''*. |
| b. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| c. Push the handler (HANDLER_ n { catch'* }) to the stack. |
| d. Push the value (REF.EXN_ADDR a) to the stack. |
| e. Execute the instruction THROW_REF. |
| 3. Else: |
| a. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| b. Push the values val* to the stack. |
| c. Push the value (REF.EXN_ADDR a) to the stack. |
| d. Execute the instruction (BR l). |
| e) Else if catch_0 is some CATCH_ALL, then: |
| 1. Let (CATCH_ALL l) be catch_0. |
| 2. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3. Execute the instruction (BR l). |
| f) Else if catch_0 is not CATCH_ALL_REF, then: |
| 1. Let [catch] :: catch'* be catch''*. |
| 2. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3. Push the handler (HANDLER_ n { catch'* }) to the stack. |
| 4. Push the value (REF.EXN_ADDR a) to the stack. |
| 5. Execute the instruction THROW_REF. |
| g) Else: |
| 1. Let (CATCH_ALL_REF l) be catch_0. |
| 2. Pop the handler (HANDLER_ _ { _ }) from the stack. |
| 3. Push the value (REF.EXN_ADDR a) to the stack. |
| 4. Execute the instruction (BR l). |
| 6. Else: |
| a. Assert: Due to validation, the first non-value entry of the stack is not a LABEL_. |
| b. Assert: Due to validation, the first non-value entry of the stack is not a FRAME_. |
| c. Assert: Due to validation, the first non-value entry of the stack is not a HANDLER_. |
| d. Throw the exception val' as a result. |
| |
| Step_read/try_table bt catch* instr* |
| 1. Let z be the current state. |
| 2. Let t_1^m ->_ localidx_0* t_2^n be $blocktype_(z, bt). |
| 3. Assert: Due to validation, (localidx_0* = []). |
| 4. Assert: Due to validation, there are at least m values on the top of the stack. |
| 5. Pop the values val^m from the stack. |
| 6. Push the handler (HANDLER_ n { catch* }) to the stack. |
| 7. Enter val^m :: instr* with label (LABEL_ n { [] }). |
| |
| Step_read/local.get x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, $local(z, x) is defined. |
| 3. Let ?(val) be $local(z, x). |
| 4. Push the value val to the stack. |
| |
| Step_read/global.get x |
| 1. Let z be the current state. |
| 2. Let val be $global(z, x).VALUE. |
| 3. Push the value val to the stack. |
| |
| Step_read/table.get x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If (i >= |$table(z, x).REFS|), then: |
| a. Trap. |
| 5. Push the value $table(z, x).REFS[i] to the stack. |
| |
| Step_read/table.size x |
| 1. Let z be the current state. |
| 2. Let (at lim rt) be $table(z, x).TYPE. |
| 3. Let n be |$table(z, x).REFS|. |
| 4. Push the value (at.CONST n) to the stack. |
| |
| Step_read/table.fill x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value val from the stack. |
| 6. Assert: Due to validation, a value of value type at is on the top of the stack. |
| 7. Pop the value (numtype_0.CONST i) from the stack. |
| 8. If ((i + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| 9. If (n = 0), then: |
| a. Do nothing. |
| 10. Else: |
| a. Push the value (at.CONST i) to the stack. |
| b. Push the value val to the stack. |
| c. Execute the instruction (TABLE.SET x). |
| d. Push the value (at.CONST (i + 1)) to the stack. |
| e. Push the value val to the stack. |
| f. Push the value (at.CONST (n - 1)) to the stack. |
| g. Execute the instruction (TABLE.FILL x). |
| |
| Step_read/table.copy x_1 x_2 |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at_2.CONST i_2) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at_1.CONST i_1) from the stack. |
| 8. If ((i_1 + n) > |$table(z, x_1).REFS|), then: |
| a. Trap. |
| 9. If ((i_2 + n) > |$table(z, x_2).REFS|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. If (i_1 <= i_2), then: |
| 1) Push the value (at_1.CONST i_1) to the stack. |
| 2) Push the value (at_2.CONST i_2) to the stack. |
| 3) Execute the instruction (TABLE.GET x_2). |
| 4) Execute the instruction (TABLE.SET x_1). |
| 5) Push the value (at_1.CONST (i_1 + 1)) to the stack. |
| 6) Push the value (at_2.CONST (i_2 + 1)) to the stack. |
| b. Else: |
| 1) Push the value (at_1.CONST ((i_1 + n) - 1)) to the stack. |
| 2) Push the value (at_2.CONST ((i_2 + n) - 1)) to the stack. |
| 3) Execute the instruction (TABLE.GET x_2). |
| 4) Execute the instruction (TABLE.SET x_1). |
| 5) Push the value (at_1.CONST i_1) to the stack. |
| 6) Push the value (at_2.CONST i_2) to the stack. |
| c. Push the value (at.CONST (n - 1)) to the stack. |
| d. Execute the instruction (TABLE.COPY x_1 x_2). |
| |
| Step_read/table.init x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST j) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at.CONST i) from the stack. |
| 8. If ((i + n) > |$table(z, x).REFS|), then: |
| a. Trap. |
| 9. If ((j + n) > |$elem(z, y).REFS|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. Assert: Due to validation, (j < |$elem(z, y).REFS|). |
| b. Push the value (at.CONST i) to the stack. |
| c. Push the value $elem(z, y).REFS[j] to the stack. |
| d. Execute the instruction (TABLE.SET x). |
| e. Push the value (at.CONST (i + 1)) to the stack. |
| f. Push the value (I32.CONST (j + 1)) to the stack. |
| g. Push the value (I32.CONST (n - 1)) to the stack. |
| h. Execute the instruction (TABLE.INIT x y). |
| |
| Step_read/load nt loadop_? x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If loadop_? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, x).BYTES|), then: |
| 1) Trap. |
| b. Let c be $nbytes__1^-1(nt, $mem(z, x).BYTES[(i + ao.OFFSET) : ($size(nt) / 8)]). |
| c. Push the value (nt.CONST c) to the stack. |
| 5. Else: |
| a. Assert: Due to validation, nt is Inn. |
| b. Let ?(loadop_0) be loadop_?. |
| c. Let n _ sx be loadop_0. |
| d. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, x).BYTES|), then: |
| 1) Trap. |
| e. Let c be $ibytes__1^-1(n, $mem(z, x).BYTES[(i + ao.OFFSET) : (n / 8)]). |
| f. Push the value (nt.CONST $extend__(n, $size(nt), sx, c)) to the stack. |
| |
| Step_read/vload V128 vloadop_? x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST i) from the stack. |
| 4. If vloadop_? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($vsize(V128) / 8)) > |$mem(z, x).BYTES|), then: |
| 1) Trap. |
| b. Let c be $vbytes__1^-1(V128, $mem(z, x).BYTES[(i + ao.OFFSET) : ($vsize(V128) / 8)]). |
| c. Push the value (V128.CONST c) to the stack. |
| 5. Else: |
| a. Let ?(vloadop_0) be vloadop_?. |
| b. If vloadop_0 is some SHAPE, then: |
| 1) Let (SHAPE K X M _ sx) be vloadop_0. |
| 2) If (((i + ao.OFFSET) + ((K * M) / 8)) > |$mem(z, x).BYTES|), then: |
| a) Trap. |
| 3) Let j^M be $ibytes__1^-1(K, $mem(z, x).BYTES[((i + ao.OFFSET) + ((k * K) / 8)) : (K / 8)])^(k<M). |
| 4) Let Jnn be $jsizenn^-1((K * 2)). |
| 5) Let c be $inv_lanes_(Jnn X M, $extend__(K, $jsizenn(Jnn), sx, j)^M). |
| 6) Push the value (V128.CONST c) to the stack. |
| c. If vloadop_0 is some SPLAT, then: |
| 1) Let (SPLAT N) be vloadop_0. |
| 2) If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, x).BYTES|), then: |
| a) Trap. |
| 3) Let M be (128 / N). |
| 4) Let Jnn be $jsize^-1(N). |
| 5) Let j be $ibytes__1^-1(N, $mem(z, x).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 6) Let c be $inv_lanes_(Jnn X M, j^M). |
| 7) Push the value (V128.CONST c) to the stack. |
| d. If vloadop_0 is some ZERO, then: |
| 1) Let (ZERO N) be vloadop_0. |
| 2) If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, x).BYTES|), then: |
| a) Trap. |
| 3) Let j be $ibytes__1^-1(N, $mem(z, x).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 4) Let c be $extend__(N, 128, U, j). |
| 5) Push the value (V128.CONST c) to the stack. |
| |
| Step_read/vload_lane V128 N x ao j |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 3. Pop the value (V128.CONST c_1) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + (N / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 7. Let M be ($vsize(V128) / N). |
| 8. Let Jnn be $jsize^-1(N). |
| 9. Let k be $ibytes__1^-1(N, $mem(z, x).BYTES[(i + ao.OFFSET) : (N / 8)]). |
| 10. Let c be $inv_lanes_(Jnn X M, $lanes_(Jnn X M, c_1) with [j] replaced by k). |
| 11. Push the value (V128.CONST c) to the stack. |
| |
| Step_read/memory.size x |
| 1. Let z be the current state. |
| 2. Let at lim PAGE be $mem(z, x).TYPE. |
| 3. Let (n * (64 * $Ki())) be |$mem(z, x).BYTES|. |
| 4. Push the value (at.CONST n) to the stack. |
| |
| Step_read/memory.fill x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value val from the stack. |
| 6. Assert: Due to validation, a value of value type at is on the top of the stack. |
| 7. Pop the value (numtype_0.CONST i) from the stack. |
| 8. If ((i + n) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 9. If (n = 0), then: |
| a. Do nothing. |
| 10. Else: |
| a. Push the value (at.CONST i) to the stack. |
| b. Push the value val to the stack. |
| c. Execute the instruction (STORE I32 ?(8) x $memarg0()). |
| d. Push the value (at.CONST (i + 1)) to the stack. |
| e. Push the value val to the stack. |
| f. Push the value (at.CONST (n - 1)) to the stack. |
| g. Execute the instruction (MEMORY.FILL x). |
| |
| Step_read/memory.copy x_1 x_2 |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at_2.CONST i_2) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at_1.CONST i_1) from the stack. |
| 8. If ((i_1 + n) > |$mem(z, x_1).BYTES|), then: |
| a. Trap. |
| 9. If ((i_2 + n) > |$mem(z, x_2).BYTES|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. If (i_1 <= i_2), then: |
| 1) Push the value (at_1.CONST i_1) to the stack. |
| 2) Push the value (at_2.CONST i_2) to the stack. |
| 3) Execute the instruction (LOAD I32 ?(8 _ U) x_2 $memarg0()). |
| 4) Execute the instruction (STORE I32 ?(8) x_1 $memarg0()). |
| 5) Push the value (at_1.CONST (i_1 + 1)) to the stack. |
| 6) Push the value (at_2.CONST (i_2 + 1)) to the stack. |
| b. Else: |
| 1) Push the value (at_1.CONST ((i_1 + n) - 1)) to the stack. |
| 2) Push the value (at_2.CONST ((i_2 + n) - 1)) to the stack. |
| 3) Execute the instruction (LOAD I32 ?(8 _ U) x_2 $memarg0()). |
| 4) Execute the instruction (STORE I32 ?(8) x_1 $memarg0()). |
| 5) Push the value (at_1.CONST i_1) to the stack. |
| 6) Push the value (at_2.CONST i_2) to the stack. |
| c. Push the value (at.CONST (n - 1)) to the stack. |
| d. Execute the instruction (MEMORY.COPY x_1 x_2). |
| |
| Step_read/memory.init x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST j) from the stack. |
| 6. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 7. Pop the value (at.CONST i) from the stack. |
| 8. If ((i + n) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 9. If ((j + n) > |$data(z, y).BYTES|), then: |
| a. Trap. |
| 10. If (n = 0), then: |
| a. Do nothing. |
| 11. Else: |
| a. Assert: Due to validation, (j < |$data(z, y).BYTES|). |
| b. Push the value (at.CONST i) to the stack. |
| c. Push the value (I32.CONST $data(z, y).BYTES[j]) to the stack. |
| d. Execute the instruction (STORE I32 ?(8) x $memarg0()). |
| e. Push the value (at.CONST (i + 1)) to the stack. |
| f. Push the value (I32.CONST (j + 1)) to the stack. |
| g. Push the value (I32.CONST (n - 1)) to the stack. |
| h. Execute the instruction (MEMORY.INIT x y). |
| |
| Step_read/ref.null ht |
| 1. Push the value REF.NULL_ADDR to the stack. |
| |
| Step_read/ref.func x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (x < |$moduleinst(z).FUNCS|). |
| 3. Push the value (REF.FUNC_ADDR $moduleinst(z).FUNCS[x]) to the stack. |
| |
| Step_read/ref.test rt |
| 1. Let (FRAME_ _ { f }) be the topmost FRAME_. |
| 2. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 3. Pop the value ref from the stack. |
| 4. If $Ref_ok(ref, $inst_reftype(f.MODULE, rt)), then: |
| a. Push the value (I32.CONST 1) to the stack. |
| 5. Else: |
| a. Push the value (I32.CONST 0) to the stack. |
| |
| Step_read/ref.cast rt |
| 1. Let (FRAME_ _ { f }) be the topmost FRAME_. |
| 2. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 3. Pop the value ref from the stack. |
| 4. If not $Ref_ok(ref, $inst_reftype(f.MODULE, rt)), then: |
| a. Trap. |
| 5. Push the value ref to the stack. |
| |
| Step_read/struct.new_default x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, $Expand($type(z, x)) is some STRUCT. |
| 3. Let (STRUCT list_0) be $Expand($type(z, x)). |
| 4. Let (mut? zt)* be list_0. |
| 5. Assert: Due to validation, $default_($unpack(zt)) is defined*. |
| 6. Let val* be []. |
| 7. For each zt in zt*, do: |
| a. Let ?(val) be $default_($unpack(zt)). |
| b. Append val to the val*. |
| 8. Assert: Due to validation, (|val*| = |zt*|). |
| 9. Push the values val* to the stack. |
| 10. Execute the instruction (STRUCT.NEW x). |
| |
| Step_read/struct.get 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 val from the stack. |
| 4. If (val = REF.NULL_ADDR), then: |
| a. Trap. |
| 5. Assert: Due to validation, val is some REF.STRUCT_ADDR. |
| 6. Let (REF.STRUCT_ADDR a) be val. |
| 7. Assert: Due to validation, (i < |$structinst(z)[a].FIELDS|). |
| 8. Assert: Due to validation, (a < |$structinst(z)|). |
| 9. Assert: Due to validation, $Expand($type(z, x)) is some STRUCT. |
| 10. Let (STRUCT list_0) be $Expand($type(z, x)). |
| 11. Let (mut? zt)* be list_0. |
| 12. Assert: Due to validation, (i < |zt*|). |
| 13. Push the value $unpackfield_(zt*[i], sx?, $structinst(z)[a].FIELDS[i]) to the stack. |
| |
| Step_read/array.new_default x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, $Expand($type(z, x)) is some ARRAY. |
| 5. Let (ARRAY fieldtype_0) be $Expand($type(z, x)). |
| 6. Let (mut? zt) be fieldtype_0. |
| 7. Assert: Due to validation, $default_($unpack(zt)) is defined. |
| 8. Let ?(val) be $default_($unpack(zt)). |
| 9. Push the values val^n to the stack. |
| 10. Execute the instruction (ARRAY.NEW_FIXED x n). |
| |
| Step_read/array.new_elem x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. If ((i + n) > |$elem(z, y).REFS|), then: |
| a. Trap. |
| 7. Let ref^n be $elem(z, y).REFS[i : n]. |
| 8. Push the values ref^n to the stack. |
| 9. Execute the instruction (ARRAY.NEW_FIXED x n). |
| |
| Step_read/array.new_data x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, $Expand($type(z, x)) is some ARRAY. |
| 7. Let (ARRAY fieldtype_0) be $Expand($type(z, x)). |
| 8. Let (mut? zt) be fieldtype_0. |
| 9. If ((i + ((n * $zsize(zt)) / 8)) > |$data(z, y).BYTES|), then: |
| a. Trap. |
| 10. Let byte** be $concatn__1^-1(`byte, ($zsize(zt) / 8), $data(z, y).BYTES[i : ((n * $zsize(zt)) / 8)]). |
| 11. Let c^n be $zbytes__1^-1(zt, byte*)*. |
| 12. Push the values $const($cunpack(zt), $cunpacknum_(zt, c))^n to the stack. |
| 13. Execute the instruction (ARRAY.NEW_FIXED x n). |
| |
| Step_read/array.get sx? x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST i) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value val from the stack. |
| 6. If (val = REF.NULL_ADDR), then: |
| a. Trap. |
| 7. Assert: Due to validation, val is some REF.ARRAY_ADDR. |
| 8. Let (REF.ARRAY_ADDR a) be val. |
| 9. Assert: Due to validation, (a < |$arrayinst(z)|). |
| 10. If (i >= |$arrayinst(z)[a].FIELDS|), then: |
| a. Trap. |
| 11. Assert: Due to validation, $Expand($type(z, x)) is some ARRAY. |
| 12. Let (ARRAY fieldtype_0) be $Expand($type(z, x)). |
| 13. Let (mut? zt) be fieldtype_0. |
| 14. Push the value $unpackfield_(zt, sx?, $arrayinst(z)[a].FIELDS[i]) to the stack. |
| |
| Step_read/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 val from the stack. |
| 4. If (val = REF.NULL_ADDR), then: |
| a. Trap. |
| 5. Assert: Due to validation, val is some REF.ARRAY_ADDR. |
| 6. Let (REF.ARRAY_ADDR a) be val. |
| 7. Assert: Due to validation, (a < |$arrayinst(z)|). |
| 8. Push the value (I32.CONST |$arrayinst(z)[a].FIELDS|) to the stack. |
| |
| Step_read/array.fill x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value val from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST i) from the stack. |
| 8. Assert: Due to validation, a value is on the top of the stack. |
| 9. Pop the value val' from the stack. |
| 10. If (val' = REF.NULL_ADDR), then: |
| a. Trap. |
| 11. Assert: Due to validation, val' is some REF.ARRAY_ADDR. |
| 12. Let (REF.ARRAY_ADDR a) be val'. |
| 13. If (a >= |$arrayinst(z)|), then: |
| a. Do nothing. |
| 14. Else if ((i + n) > |$arrayinst(z)[a].FIELDS|), then: |
| a. Trap. |
| 15. If (n = 0), then: |
| a. Do nothing. |
| 16. Else: |
| a. Push the value (REF.ARRAY_ADDR a) to the stack. |
| b. Push the value (I32.CONST i) to the stack. |
| c. Push the value val to the stack. |
| d. Execute the instruction (ARRAY.SET x). |
| e. Push the value (REF.ARRAY_ADDR a) to the stack. |
| f. Push the value (I32.CONST (i + 1)) to the stack. |
| g. Push the value val to the stack. |
| h. Push the value (I32.CONST (n - 1)) to the stack. |
| i. Execute the instruction (ARRAY.FILL x). |
| |
| Step_read/array.copy x_1 x_2 |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i_2) from the stack. |
| 6. Assert: Due to validation, a value is on the top of the stack. |
| 7. Pop the value val from the stack. |
| 8. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 9. Pop the value (I32.CONST i_1) from the stack. |
| 10. Assert: Due to validation, a value is on the top of the stack. |
| 11. Pop the value val' from the stack. |
| 12. If ((val' = REF.NULL_ADDR) /\ val is ref), then: |
| a. Trap. |
| 13. If ((val = REF.NULL_ADDR) /\ val' is ref), then: |
| a. Trap. |
| 14. If val' is some REF.ARRAY_ADDR, then: |
| a. Let (REF.ARRAY_ADDR a_1) be val'. |
| b. If val is some REF.ARRAY_ADDR, then: |
| 1) If ((a_1 < |$arrayinst(z)|) /\ ((i_1 + n) > |$arrayinst(z)[a_1].FIELDS|)), then: |
| a) Trap. |
| 2) Let (REF.ARRAY_ADDR a_2) be val. |
| 3) If (a_2 >= |$arrayinst(z)|), then: |
| a) Do nothing. |
| 4) Else if ((i_2 + n) > |$arrayinst(z)[a_2].FIELDS|), then: |
| a) Trap. |
| 5) If (n = 0), then: |
| a) Do nothing. |
| 6) Else: |
| a) Assert: Due to validation, $Expand($type(z, x_2)) is some ARRAY. |
| b) Let (ARRAY fieldtype_0) be $Expand($type(z, x_2)). |
| c) Let (mut? zt_2) be fieldtype_0. |
| d) Let sx? be $sx(zt_2). |
| e) Push the value (REF.ARRAY_ADDR a_1) to the stack. |
| f) If (i_1 <= i_2), then: |
| 1. Push the value (I32.CONST i_1) to the stack. |
| 2. Push the value (REF.ARRAY_ADDR a_2) to the stack. |
| 3. Push the value (I32.CONST i_2) to the stack. |
| 4. Execute the instruction (ARRAY.GET sx? x_2). |
| 5. Execute the instruction (ARRAY.SET x_1). |
| 6. Push the value (REF.ARRAY_ADDR a_1) to the stack. |
| 7. Push the value (I32.CONST (i_1 + 1)) to the stack. |
| 8. Push the value (REF.ARRAY_ADDR a_2) to the stack. |
| 9. Push the value (I32.CONST (i_2 + 1)) to the stack. |
| g) Else: |
| 1. Push the value (I32.CONST ((i_1 + n) - 1)) to the stack. |
| 2. Push the value (REF.ARRAY_ADDR a_2) to the stack. |
| 3. Push the value (I32.CONST ((i_2 + n) - 1)) to the stack. |
| 4. Execute the instruction (ARRAY.GET sx? x_2). |
| 5. Execute the instruction (ARRAY.SET x_1). |
| 6. Push the value (REF.ARRAY_ADDR a_1) to the stack. |
| 7. Push the value (I32.CONST i_1) to the stack. |
| 8. Push the value (REF.ARRAY_ADDR a_2) to the stack. |
| 9. Push the value (I32.CONST i_2) to the stack. |
| h) Push the value (I32.CONST (n - 1)) to the stack. |
| i) Execute the instruction (ARRAY.COPY x_1 x_2). |
| |
| Step_read/array.init_elem x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST j) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST i) from the stack. |
| 8. Assert: Due to validation, a value is on the top of the stack. |
| 9. Pop the value val from the stack. |
| 10. If (val = REF.NULL_ADDR), then: |
| a. Trap. |
| 11. Assert: Due to validation, val is some REF.ARRAY_ADDR. |
| 12. Let (REF.ARRAY_ADDR a) be val. |
| 13. If ((a < |$arrayinst(z)|) /\ ((i + n) > |$arrayinst(z)[a].FIELDS|)), then: |
| a. Trap. |
| 14. If ((j + n) > |$elem(z, y).REFS|), then: |
| a. Trap. |
| 15. If (n = 0), then: |
| a. Do nothing. |
| 16. Else if (j < |$elem(z, y).REFS|), then: |
| a. Let ref be $elem(z, y).REFS[j]. |
| b. Push the value (REF.ARRAY_ADDR a) to the stack. |
| c. Push the value (I32.CONST i) to the stack. |
| d. Push the value ref to the stack. |
| e. Execute the instruction (ARRAY.SET x). |
| f. Push the value (REF.ARRAY_ADDR a) to the stack. |
| g. Push the value (I32.CONST (i + 1)) to the stack. |
| h. Push the value (I32.CONST (j + 1)) to the stack. |
| i. Push the value (I32.CONST (n - 1)) to the stack. |
| j. Execute the instruction (ARRAY.INIT_ELEM x y). |
| |
| Step_read/array.init_data x y |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 3. Pop the value (I32.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST j) from the stack. |
| 6. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 7. Pop the value (I32.CONST i) from the stack. |
| 8. Assert: Due to validation, a value is on the top of the stack. |
| 9. Pop the value val from the stack. |
| 10. If (val = REF.NULL_ADDR), then: |
| a. Trap. |
| 11. Assert: Due to validation, val is some REF.ARRAY_ADDR. |
| 12. Let (REF.ARRAY_ADDR a) be val. |
| 13. If ((a < |$arrayinst(z)|) /\ ((i + n) > |$arrayinst(z)[a].FIELDS|)), then: |
| a. Trap. |
| 14. If $Expand($type(z, x)) is some ARRAY, then: |
| a. Let (ARRAY fieldtype_0) be $Expand($type(z, x)). |
| b. Let (mut? zt) be fieldtype_0. |
| c. If ((j + ((n * $zsize(zt)) / 8)) > |$data(z, y).BYTES|), then: |
| 1) Trap. |
| d. If (n = 0), then: |
| 1) Do nothing. |
| e. Else: |
| 1) Let c be $zbytes__1^-1(zt, $data(z, y).BYTES[j : ($zsize(zt) / 8)]). |
| 2) Push the value (REF.ARRAY_ADDR a) to the stack. |
| 3) Push the value (I32.CONST i) to the stack. |
| 4) Push the value $const($cunpack(zt), $cunpacknum_(zt, c)) to the stack. |
| 5) Execute the instruction (ARRAY.SET x). |
| 6) Push the value (REF.ARRAY_ADDR a) to the stack. |
| 7) Push the value (I32.CONST (i + 1)) to the stack. |
| 8) Push the value (I32.CONST (j + ($zsize(zt) / 8))) to the stack. |
| 9) Push the value (I32.CONST (n - 1)) to the stack. |
| 10) Execute the instruction (ARRAY.INIT_DATA x y). |
| 15. Else if (n = 0), then: |
| a. Do nothing. |
| |
| Step/throw x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, (x < |$tagaddr(z)|). |
| 3. Assert: Due to validation, $Expand($as_deftype($tag(z, x).TYPE)) is some ->. |
| 4. Let (FUNC t^n -> resulttype_0) be $Expand($as_deftype($tag(z, x).TYPE)). |
| 5. Assert: Due to validation, (resulttype_0 = []). |
| 6. Let a be |$exninst(z)|. |
| 7. Assert: Due to validation, there are at least n values on the top of the stack. |
| 8. Pop the values val^n from the stack. |
| 9. Let exn be { TAG: $tagaddr(z)[x]; FIELDS: val^n }. |
| 10. Perform $add_exninst(z, [exn]). |
| 11. Push the value (REF.EXN_ADDR a) to the stack. |
| 12. Execute the instruction THROW_REF. |
| |
| Step/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 val from the stack. |
| 4. Perform $with_local(z, x, val). |
| |
| Step/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 val from the stack. |
| 4. Perform $with_global(z, x, val). |
| |
| Step/table.set x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 3. Pop the value ref from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at.CONST i) from the stack. |
| 6. If (i >= |$table(z, x).REFS|), then: |
| a. Trap. |
| 7. Perform $with_table(z, x, i, ref). |
| |
| Step/table.grow x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Assert: Due to validation, a value of value type ref is on the top of the stack. |
| 5. Pop the value ref from the stack. |
| 6. Either: |
| a. Let ti be $growtable($table(z, x), n, ref). |
| b. Push the value (at.CONST |$table(z, x).REFS|) to the stack. |
| c. Perform $with_tableinst(z, x, ti). |
| 7. Or: |
| a. Push the value (at.CONST $inv_signed_($size(at), (- 1))) to the stack. |
| |
| Step/elem.drop x |
| 1. Let z be the current state. |
| 2. Perform $with_elem(z, x, []). |
| |
| Step/store nt storeop_? x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (nt'.CONST c) from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value (at.CONST i) from the stack. |
| 6. Assert: Due to validation, (nt = nt'). |
| 7. If storeop_? is not defined, then: |
| a. If (((i + ao.OFFSET) + ($size(nt') / 8)) > |$mem(z, x).BYTES|), then: |
| 1) Trap. |
| b. Let b* be $nbytes_(nt', c). |
| c. Perform $with_mem(z, x, (i + ao.OFFSET), ($size(nt') / 8), b*). |
| 8. Else: |
| a. Assert: Due to validation, nt' is Inn. |
| b. Let ?(n) be storeop_?. |
| c. If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, x).BYTES|), then: |
| 1) Trap. |
| d. Let b* be $ibytes_(n, $wrap__($size(nt'), n, c)). |
| e. Perform $with_mem(z, x, (i + ao.OFFSET), (n / 8), b*). |
| |
| Step/vstore V128 x ao |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 3. Pop the value (V128.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + ($vsize(V128) / 8)) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 7. Let b* be $vbytes_(V128, c). |
| 8. Perform $with_mem(z, x, (i + ao.OFFSET), ($vsize(V128) / 8), b*). |
| |
| Step/vstore_lane V128 N x ao j |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type V128 is on the top of the stack. |
| 3. Pop the value (V128.CONST c) from the stack. |
| 4. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 5. Pop the value (at.CONST i) from the stack. |
| 6. If (((i + ao.OFFSET) + N) > |$mem(z, x).BYTES|), then: |
| a. Trap. |
| 7. Let M be (128 / N). |
| 8. Let Jnn be $jsize^-1(N). |
| 9. Assert: Due to validation, (j < |$lanes_(Jnn X M, c)|). |
| 10. Let b* be $ibytes_(N, $lanes_(Jnn X M, c)[j]). |
| 11. Perform $with_mem(z, x, (i + ao.OFFSET), (N / 8), b*). |
| |
| Step/memory.grow x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, a value of value type num is on the top of the stack. |
| 3. Pop the value (at.CONST n) from the stack. |
| 4. Either: |
| a. Let mi be $growmem($mem(z, x), n). |
| b. Push the value (at.CONST (|$mem(z, x).BYTES| / (64 * $Ki()))) to the stack. |
| c. Perform $with_meminst(z, x, mi). |
| 5. Or: |
| a. Push the value (at.CONST $inv_signed_($size(at), (- 1))) to the stack. |
| |
| Step/data.drop x |
| 1. Let z be the current state. |
| 2. Perform $with_data(z, x, []). |
| |
| Step/struct.new x |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, $Expand($type(z, x)) is some STRUCT. |
| 3. Let (STRUCT list_0) be $Expand($type(z, x)). |
| 4. Let (mut? zt)^n be list_0. |
| 5. Let a be |$structinst(z)|. |
| 6. Assert: Due to validation, there are at least n values on the top of the stack. |
| 7. Pop the values val^n from the stack. |
| 8. Let si be { TYPE: $type(z, x); FIELDS: $packfield_(zt, val)^n }. |
| 9. Push the value (REF.STRUCT_ADDR a) to the stack. |
| 10. Perform $add_structinst(z, [si]). |
| |
| Step/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 val from the stack. |
| 4. Assert: Due to validation, a value is on the top of the stack. |
| 5. Pop the value val' from the stack. |
| 6. If (val' = REF.NULL_ADDR), then: |
| a. Trap. |
| 7. Assert: Due to validation, val' is some REF.STRUCT_ADDR. |
| 8. Let (REF.STRUCT_ADDR a) be val'. |
| 9. Assert: Due to validation, $Expand($type(z, x)) is some STRUCT. |
| 10. Let (STRUCT list_0) be $Expand($type(z, x)). |
| 11. Let (mut? zt)* be list_0. |
| 12. Assert: Due to validation, (i < |zt*|). |
| 13. Perform $with_struct(z, a, i, $packfield_(zt*[i], val)). |
| |
| Step/array.new_fixed x n |
| 1. Let z be the current state. |
| 2. Assert: Due to validation, $Expand($type(z, x)) is some ARRAY. |
| 3. Let (ARRAY fieldtype_0) be $Expand($type(z, x)). |
| 4. Let (mut? zt) be fieldtype_0. |
| 5. Let a be |$arrayinst(z)|. |
| 6. Assert: Due to validation, there are at least n values on the top of the stack. |
| 7. Pop the values val^n from the stack. |
| 8. Let ai be { TYPE: $type(z, x); FIELDS: $packfield_(zt, val)^n }. |
| 9. Push the value (REF.ARRAY_ADDR a) to the stack. |
| 10. Perform $add_arrayinst(z, [ai]). |
| |
| Step/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 val from the stack. |
| 4. Assert: Due to validation, a value of value type I32 is on the top of the stack. |
| 5. Pop the value (I32.CONST i) from the stack. |
| 6. Assert: Due to validation, a value is on the top of the stack. |
| 7. Pop the value val' from the stack. |
| 8. If (val' = REF.NULL_ADDR), then: |
| a. Trap. |
| 9. Assert: Due to validation, val' is some REF.ARRAY_ADDR. |
| 10. Let (REF.ARRAY_ADDR a) be val'. |
| 11. If ((a < |$arrayinst(z)|) /\ (i >= |$arrayinst(z)[a].FIELDS|)), then: |
| a. Trap. |
| 12. Assert: Due to validation, $Expand($type(z, x)) is some ARRAY. |
| 13. Let (ARRAY fieldtype_0) be $Expand($type(z, x)). |
| 14. Let (mut? zt) be fieldtype_0. |
| 15. Perform $with_array(z, a, i, $packfield_(zt, val)). |
| |
| min i j |
| 1. If (i <= j), then: |
| a. Return i. |
| 2. Return j. |
| |
| sum n''* |
| 1. If (n''* = []), then: |
| a. Return 0. |
| 2. Let [n] :: n'* be n''*. |
| 3. Return (n + $sum(n'*)). |
| |
| prod n''* |
| 1. If (n''* = []), then: |
| a. Return 1. |
| 2. Let [n] :: n'* be n''*. |
| 3. Return (n * $prod(n'*)). |
| |
| opt_ `X X* |
| 1. If (X* = []), then: |
| a. Return ?(). |
| 2. Assert: Due to validation, (|X*| = 1). |
| 3. Let [w] be X*. |
| 4. Return ?(w). |
| |
| concat_ `X X* |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w*] :: w'** be X*. |
| 3. Return w* :: $concat_(`X, w'**). |
| |
| concatn_ `X X* n |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w^n] :: w'^n* be X*. |
| 3. Return w^n :: $concatn_(`X, w'^n*, n). |
| |
| concatopt_ `X X* |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w?] :: w'?* be X*. |
| 3. Return w? :: $concat_(`X, w'?*). |
| |
| disjoint_ `X X* |
| 1. If (X* = []), then: |
| a. Return true. |
| 2. Let [w] :: w'* be X*. |
| 3. Return (w is not contained in w'* /\ $disjoint_(`X, w'*)). |
| |
| setminus1_ `X w X* |
| 1. If (X* = []), then: |
| a. Return [w]. |
| 2. Let [w_1] :: w'* be X*. |
| 3. If (w = w_1), then: |
| a. Return []. |
| 4. Return $setminus1_(`X, w, w'*). |
| |
| setminus_ `X X* w* |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w_1] :: w'* be X*. |
| 3. Return $setminus1_(`X, w_1, w*) :: $setminus_(`X, w'*, w*). |
| |
| setproduct2_ `X w_1 X* |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w'*] :: w** be X*. |
| 3. Return [[w_1] :: w'*] :: $setproduct2_(`X, w_1, w**). |
| |
| setproduct1_ `X X* w** |
| 1. If (X* = []), then: |
| a. Return []. |
| 2. Let [w_1] :: w'* be X*. |
| 3. Return $setproduct2_(`X, w_1, w**) :: $setproduct1_(`X, w'*, w**). |
| |
| setproduct_ `X X* |
| 1. If (X* = []), then: |
| a. Return [[]]. |
| 2. Let [w_1*] :: w** be X*. |
| 3. Return $setproduct1_(`X, w_1*, $setproduct_(`X, w**)). |
| |
| signif N |
| 1. If (N = 32), then: |
| a. Return 23. |
| 2. Assert: Due to validation, (N = 64). |
| 3. Return 52. |
| |
| expon N |
| 1. If (N = 32), then: |
| a. Return 8. |
| 2. Assert: Due to validation, (N = 64). |
| 3. Return 11. |
| |
| M N |
| 1. Return $signif(N). |
| |
| E N |
| 1. Return $expon(N). |
| |
| fzero N |
| 1. Return (POS (SUBNORM 0)). |
| |
| fnat N n |
| 1. Return (POS (NORM n 0)). |
| |
| fone N |
| 1. Return (POS (NORM 1 0)). |
| |
| canon_ N |
| 1. Return (2 ^ ($signif(N) - 1)). |
| |
| cont b |
| 1. Assert: Due to validation, (128 < b). |
| 2. Assert: Due to validation, (b < 192). |
| 3. Return (b - 128). |
| |
| funcsxx externidx'* |
| 1. If (externidx'* = []), then: |
| a. Return []. |
| 2. Let [externidx_0] :: xx* be externidx'*. |
| 3. If externidx_0 is some FUNC, then: |
| a. Let (FUNC x) be externidx_0. |
| b. Return [x] :: $funcsxx(xx*). |
| 4. Let [externidx] :: xx* be externidx'*. |
| 5. Return $funcsxx(xx*). |
| |
| globalsxx externidx'* |
| 1. If (externidx'* = []), then: |
| a. Return []. |
| 2. Let [externidx_0] :: xx* be externidx'*. |
| 3. If externidx_0 is some GLOBAL, then: |
| a. Let (GLOBAL x) be externidx_0. |
| b. Return [x] :: $globalsxx(xx*). |
| 4. Let [externidx] :: xx* be externidx'*. |
| 5. Return $globalsxx(xx*). |
| |
| tablesxx externidx'* |
| 1. If (externidx'* = []), then: |
| a. Return []. |
| 2. Let [externidx_0] :: xx* be externidx'*. |
| 3. If externidx_0 is some TABLE, then: |
| a. Let (TABLE x) be externidx_0. |
| b. Return [x] :: $tablesxx(xx*). |
| 4. Let [externidx] :: xx* be externidx'*. |
| 5. Return $tablesxx(xx*). |
| |
| memsxx externidx'* |
| 1. If (externidx'* = []), then: |
| a. Return []. |
| 2. Let [externidx_0] :: xx* be externidx'*. |
| 3. If externidx_0 is some MEM, then: |
| a. Let (MEM x) be externidx_0. |
| b. Return [x] :: $memsxx(xx*). |
| 4. Let [externidx] :: xx* be externidx'*. |
| 5. Return $memsxx(xx*). |
| |
| tagsxx externidx'* |
| 1. If (externidx'* = []), then: |
| a. Return []. |
| 2. Let [externidx_0] :: xx* be externidx'*. |
| 3. If externidx_0 is some TAG, then: |
| a. Let (TAG x) be externidx_0. |
| b. Return [x] :: $tagsxx(xx*). |
| 4. Let [externidx] :: xx* be externidx'*. |
| 5. Return $tagsxx(xx*). |
| |
| free_opt free'? |
| 1. If free'? is not defined, then: |
| a. Return {}. |
| 2. Let ?(free) be free'?. |
| 3. Return free. |
| |
| free_list free''* |
| 1. If (free''* = []), then: |
| a. Return {}. |
| 2. Let [free] :: free'* be free''*. |
| 3. Return free ++ $free_list(free'*). |
| |
| free_typeidx typeidx |
| 1. Return { TYPES: [typeidx] }. |
| |
| free_funcidx funcidx |
| 1. Return { FUNCS: [funcidx] }. |
| |
| free_globalidx globalidx |
| 1. Return { GLOBALS: [globalidx] }. |
| |
| free_tableidx tableidx |
| 1. Return { TABLES: [tableidx] }. |
| |
| free_memidx memidx |
| 1. Return { MEMS: [memidx] }. |
| |
| free_elemidx elemidx |
| 1. Return { ELEMS: [elemidx] }. |
| |
| free_dataidx dataidx |
| 1. Return { DATAS: [dataidx] }. |
| |
| free_localidx localidx |
| 1. Return { LOCALS: [localidx] }. |
| |
| free_labelidx labelidx |
| 1. Return { LABELS: [labelidx] }. |
| |
| free_tagidx tagidx |
| 1. Return { TAGS: [tagidx] }. |
| |
| free_externidx externidx |
| 1. If externidx is some FUNC, then: |
| a. Let (FUNC funcidx) be externidx. |
| b. Return $free_funcidx(funcidx). |
| 2. If externidx is some GLOBAL, then: |
| a. Let (GLOBAL globalidx) be externidx. |
| b. Return $free_globalidx(globalidx). |
| 3. If externidx is some TABLE, then: |
| a. Let (TABLE tableidx) be externidx. |
| b. Return $free_tableidx(tableidx). |
| 4. If externidx is some MEM, then: |
| a. Let (MEM memidx) be externidx. |
| b. Return $free_memidx(memidx). |
| 5. Assert: Due to validation, externidx is some TAG. |
| 6. Let (TAG tagidx) be externidx. |
| 7. Return $free_tagidx(tagidx). |
| |
| ANYREF |
| 1. Return (REF ?(NULL) ANY). |
| |
| EQREF |
| 1. Return (REF ?(NULL) EQ). |
| |
| I31REF |
| 1. Return (REF ?(NULL) I31). |
| |
| STRUCTREF |
| 1. Return (REF ?(NULL) STRUCT). |
| |
| ARRAYREF |
| 1. Return (REF ?(NULL) ARRAY). |
| |
| FUNCREF |
| 1. Return (REF ?(NULL) FUNC). |
| |
| EXNREF |
| 1. Return (REF ?(NULL) EXN). |
| |
| EXTERNREF |
| 1. Return (REF ?(NULL) EXTERN). |
| |
| NULLREF |
| 1. Return (REF ?(NULL) NONE). |
| |
| NULLFUNCREF |
| 1. Return (REF ?(NULL) NOFUNC). |
| |
| NULLEXNREF |
| 1. Return (REF ?(NULL) NOEXN). |
| |
| NULLEXTERNREF |
| 1. Return (REF ?(NULL) NOEXTERN). |
| |
| IN N |
| 1. If (N = 32), then: |
| a. Return I32. |
| 2. Assert: Due to validation, (N = 64). |
| 3. Return I64. |
| |
| FN N |
| 1. If (N = 32), then: |
| a. Return F32. |
| 2. Assert: Due to validation, (N = 64). |
| 3. Return F64. |
| |
| JN N |
| 1. If (N = 8), then: |
| a. Return I8. |
| 2. If (N = 16), then: |
| a. Return I16. |
| 3. If (N = 32), then: |
| a. Return I32. |
| 4. Assert: Due to validation, (N = 64). |
| 5. Return I64. |
| |
| size numtype |
| 1. If (numtype = I32), then: |
| a. Return 32. |
| 2. If (numtype = I64), then: |
| a. Return 64. |
| 3. If (numtype = F32), then: |
| a. Return 32. |
| 4. Assert: Due to validation, (numtype = F64). |
| 5. Return 64. |
| |
| vsize V128 |
| 1. Return 128. |
| |
| psize packtype |
| 1. If (packtype = I8), then: |
| a. Return 8. |
| 2. Assert: Due to validation, (packtype = I16). |
| 3. Return 16. |
| |
| lsize lanetype |
| 1. If lanetype is numtype, then: |
| a. Return $size(lanetype). |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return $psize(lanetype). |
| |
| zsize storagetype |
| 1. If storagetype is numtype, then: |
| a. Return $size(storagetype). |
| 2. If storagetype is vectype, then: |
| a. Return $vsize(storagetype). |
| 3. Assert: Due to validation, storagetype is packtype. |
| 4. Return $psize(storagetype). |
| |
| isize Inn |
| 1. Return $size(Inn). |
| |
| jsize Jnn |
| 1. Return $lsize(Jnn). |
| |
| fsize Fnn |
| 1. Return $size(Fnn). |
| |
| inv_isize n |
| 1. If (n = 32), then: |
| a. Return I32. |
| 2. If (n = 64), then: |
| a. Return I64. |
| 3. Fail. |
| |
| inv_jsize n |
| 1. If (n = 8), then: |
| a. Return I8. |
| 2. If (n = 16), then: |
| a. Return I16. |
| 3. Return $inv_isize(n). |
| |
| inv_fsize n |
| 1. If (n = 32), then: |
| a. Return F32. |
| 2. If (n = 64), then: |
| a. Return F64. |
| 3. Fail. |
| |
| sizenn nt |
| 1. Return $size(nt). |
| |
| sizenn1 nt |
| 1. Return $size(nt). |
| |
| sizenn2 nt |
| 1. Return $size(nt). |
| |
| vsizenn vt |
| 1. Return $vsize(vt). |
| |
| psizenn pt |
| 1. Return $psize(pt). |
| |
| lsizenn lt |
| 1. Return $lsize(lt). |
| |
| lsizenn1 lt |
| 1. Return $lsize(lt). |
| |
| lsizenn2 lt |
| 1. Return $lsize(lt). |
| |
| jsizenn Jnn |
| 1. Return $lsize(Jnn). |
| |
| inv_jsizenn n |
| 1. Return $inv_jsize(n). |
| |
| lunpack lanetype |
| 1. If lanetype is numtype, then: |
| a. Return lanetype. |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return I32. |
| |
| unpack storagetype |
| 1. If storagetype is valtype, then: |
| a. Return storagetype. |
| 2. Assert: Due to validation, storagetype is packtype. |
| 3. Return I32. |
| |
| nunpack storagetype |
| 1. If storagetype is numtype, then: |
| a. Return storagetype. |
| 2. If storagetype is packtype, then: |
| a. Return I32. |
| 3. Fail. |
| |
| vunpack vectype |
| 1. Return vectype. |
| |
| cunpack storagetype |
| 1. If storagetype is consttype, then: |
| a. Return storagetype. |
| 2. If storagetype is packtype, then: |
| a. Return I32. |
| 3. If storagetype is lanetype, then: |
| a. Return $lunpack(storagetype). |
| 4. Fail. |
| |
| minat at_1 at_2 |
| 1. If ($size(at_1) <= $size(at_2)), then: |
| a. Return at_1. |
| 2. Return at_2. |
| |
| diffrt (REF null_1? ht_1) (REF null? ht_2) |
| 1. If (null? = ?(NULL)), then: |
| a. Return (REF ?() ht_1). |
| 2. Assert: Due to validation, null? is not defined. |
| 3. Return (REF null_1? ht_1). |
| |
| as_deftype dt |
| 1. Return dt. |
| |
| tagsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some TAG, then: |
| a. Let (TAG jt) be externtype_0. |
| b. Return [jt] :: $tagsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $tagsxt(xt*). |
| |
| globalsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some GLOBAL, then: |
| a. Let (GLOBAL gt) be externtype_0. |
| b. Return [gt] :: $globalsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $globalsxt(xt*). |
| |
| memsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some MEM, then: |
| a. Let (MEM mt) be externtype_0. |
| b. Return [mt] :: $memsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $memsxt(xt*). |
| |
| tablesxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some TABLE, then: |
| a. Let (TABLE tt) be externtype_0. |
| b. Return [tt] :: $tablesxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $tablesxt(xt*). |
| |
| funcsxt externtype'* |
| 1. If (externtype'* = []), then: |
| a. Return []. |
| 2. Let [externtype_0] :: xt* be externtype'*. |
| 3. If externtype_0 is some FUNC, then: |
| a. Let (FUNC dt) be externtype_0. |
| b. Return [dt] :: $funcsxt(xt*). |
| 4. Let [externtype] :: xt* be externtype'*. |
| 5. Return $funcsxt(xt*). |
| |
| subst_typevar tv typevar* typeuse* |
| 1. If (typeuse* = []), then: |
| a. Assert: Due to validation, (typevar* = []). |
| b. Return tv. |
| 2. Else: |
| a. Let [tu_1] :: tu'* be typeuse*. |
| b. Assert: Due to validation, (|typevar*| >= 1). |
| c. Let [tv_1] :: tv'* be typevar*. |
| d. If (tv = tv_1), then: |
| 1) Return tu_1. |
| e. Return $subst_typevar(tv, tv'*, tu'*). |
| |
| minus_recs typevar* typeuse* |
| 1. If (typevar* = []), then: |
| a. If (typeuse* = []), then: |
| 1) Return ([], []). |
| 2. Else: |
| a. Let [typevar_0] :: tv* be typevar*. |
| b. If (typevar_0 is some REC /\ (|typeuse*| >= 1)), then: |
| 1) Let [tu_1] :: tu* be typeuse*. |
| 2) Return $minus_recs(tv*, tu*). |
| 3. Assert: Due to validation, (|typeuse*| >= 1). |
| 4. Let [tu_1] :: tu* be typeuse*. |
| 5. Assert: Due to validation, (|typevar*| >= 1). |
| 6. Let [typevar_0] :: tv* be typevar*. |
| 7. Assert: Due to validation, typevar_0 is some _IDX. |
| 8. Let (_IDX x) be typevar_0. |
| 9. Let (tv'*, tu'*) be $minus_recs(tv*, tu*). |
| 10. Return ([(_IDX x)] :: tv'*, [tu_1] :: tu'*). |
| |
| subst_packtype pt tv* tu* |
| 1. Return pt. |
| |
| subst_numtype nt tv* tu* |
| 1. Return nt. |
| |
| subst_vectype vt tv* tu* |
| 1. Return vt. |
| |
| subst_typeuse typeuse tv* tu* |
| 1. If typeuse is typevar, then: |
| a. Return $subst_typevar(typeuse, tv*, tu*). |
| 2. Assert: Due to validation, typeuse is deftype. |
| 3. Return $subst_deftype(typeuse, tv*, tu*). |
| |
| subst_heaptype heaptype tv* tu* |
| 1. If heaptype is typevar, then: |
| a. Return $subst_typevar(heaptype, tv*, tu*). |
| 2. If heaptype is deftype, then: |
| a. Return $subst_deftype(heaptype, tv*, tu*). |
| 3. Return heaptype. |
| |
| subst_reftype (REF null? ht) tv* tu* |
| 1. Return (REF null? $subst_heaptype(ht, tv*, tu*)). |
| |
| subst_valtype valtype tv* tu* |
| 1. If valtype is numtype, then: |
| a. Return $subst_numtype(valtype, tv*, tu*). |
| 2. If valtype is vectype, then: |
| a. Return $subst_vectype(valtype, tv*, tu*). |
| 3. If valtype is reftype, then: |
| a. Return $subst_reftype(valtype, tv*, tu*). |
| 4. Assert: Due to validation, (valtype = BOT). |
| 5. Return BOT. |
| |
| subst_storagetype storagetype tv* tu* |
| 1. If storagetype is valtype, then: |
| a. Return $subst_valtype(storagetype, tv*, tu*). |
| 2. Assert: Due to validation, storagetype is packtype. |
| 3. Return $subst_packtype(storagetype, tv*, tu*). |
| |
| subst_fieldtype (mut? zt) tv* tu* |
| 1. Return (mut? $subst_storagetype(zt, tv*, tu*)). |
| |
| subst_comptype comptype tv* tu* |
| 1. If comptype is some STRUCT, then: |
| a. Let (STRUCT ft*) be comptype. |
| b. Return (STRUCT $subst_fieldtype(ft, tv*, tu*)*). |
| 2. If comptype is some ARRAY, then: |
| a. Let (ARRAY ft) be comptype. |
| b. Return (ARRAY $subst_fieldtype(ft, tv*, tu*)). |
| 3. Assert: Due to validation, comptype is some ->. |
| 4. Let (FUNC t_1* -> t_2*) be comptype. |
| 5. Return (FUNC $subst_valtype(t_1, tv*, tu*)* -> $subst_valtype(t_2, tv*, tu*)*). |
| |
| subst_subtype (SUB final? tu'* ct) tv* tu* |
| 1. Return (SUB final? $subst_typeuse(tu', tv*, tu*)* $subst_comptype(ct, tv*, tu*)). |
| |
| subst_rectype (REC st*) tv* tu* |
| 1. Let (tv'*, tu'*) be $minus_recs(tv*, tu*). |
| 2. Return (REC $subst_subtype(st, tv'*, tu'*)*). |
| |
| subst_deftype (_DEF qt i) tv* tu* |
| 1. Return (_DEF $subst_rectype(qt, tv*, tu*) i). |
| |
| subst_addrtype at tv* tu* |
| 1. Return at. |
| |
| subst_tagtype tu' tv* tu* |
| 1. Return $subst_typeuse(tu', tv*, tu*). |
| |
| subst_globaltype (mut? t) tv* tu* |
| 1. Return (mut? $subst_valtype(t, tv*, tu*)). |
| |
| subst_memtype at lim PAGE tv* tu* |
| 1. Return at lim PAGE. |
| |
| subst_tabletype (at lim rt) tv* tu* |
| 1. Return (at lim $subst_reftype(rt, tv*, tu*)). |
| |
| subst_externtype externtype tv* tu* |
| 1. If externtype is some TAG, then: |
| a. Let (TAG jt) be externtype. |
| b. Return (TAG $subst_tagtype(jt, tv*, tu*)). |
| 2. If externtype is some GLOBAL, then: |
| a. Let (GLOBAL gt) be externtype. |
| b. Return (GLOBAL $subst_globaltype(gt, tv*, tu*)). |
| 3. If externtype is some TABLE, then: |
| a. Let (TABLE tt) be externtype. |
| b. Return (TABLE $subst_tabletype(tt, tv*, tu*)). |
| 4. If externtype is some MEM, then: |
| a. Let (MEM mt) be externtype. |
| b. Return (MEM $subst_memtype(mt, tv*, tu*)). |
| 5. Assert: Due to validation, externtype is some FUNC. |
| 6. Let (FUNC tu') be externtype. |
| 7. Return (FUNC $subst_typeuse(tu', tv*, tu*)). |
| |
| subst_moduletype xt_1* -> xt_2* tv* tu* |
| 1. Return $subst_externtype(xt_1, tv*, tu*)* -> $subst_externtype(xt_2, tv*, tu*)*. |
| |
| subst_all_valtype t tu^n |
| 1. Return $subst_valtype(t, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_reftype rt tu^n |
| 1. Return $subst_reftype(rt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_deftype dt tu^n |
| 1. Return $subst_deftype(dt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_tagtype jt tu^n |
| 1. Return $subst_tagtype(jt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_globaltype gt tu^n |
| 1. Return $subst_globaltype(gt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_memtype mt tu^n |
| 1. Return $subst_memtype(mt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_tabletype tt tu^n |
| 1. Return $subst_tabletype(tt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_externtype xt tu^n |
| 1. Return $subst_externtype(xt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_moduletype mmt tu^n |
| 1. Return $subst_moduletype(mmt, (_IDX i)^(i<n), tu^n). |
| |
| subst_all_deftypes deftype* tu* |
| 1. If (deftype* = []), then: |
| a. Return []. |
| 2. Let [dt_1] :: dt* be deftype*. |
| 3. Return [$subst_all_deftype(dt_1, tu*)] :: $subst_all_deftypes(dt*, tu*). |
| |
| rollrt x rectype |
| 1. Let (REC subtype^n) be rectype. |
| 2. Return (REC $subst_subtype(subtype, (_IDX (x + i))^(i<n), (REC i)^(i<n))^n). |
| |
| unrollrt rectype |
| 1. Let (REC subtype^n) be rectype. |
| 2. Return (REC $subst_subtype(subtype, (REC i)^(i<n), (_DEF rectype i)^(i<n))^n). |
| |
| rolldt x rectype |
| 1. Let (REC subtype^n) be $rollrt(x, rectype). |
| 2. Return (_DEF (REC subtype^n) i)^(i<n). |
| |
| unrolldt (_DEF rectype i) |
| 1. Let (REC subtype*) be $unrollrt(rectype). |
| 2. Return subtype*[i]. |
| |
| free_addrtype addrtype |
| 1. Return {}. |
| |
| free_numtype numtype |
| 1. Return {}. |
| |
| free_packtype packtype |
| 1. Return {}. |
| |
| free_lanetype lanetype |
| 1. If lanetype is numtype, then: |
| a. Return $free_numtype(lanetype). |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return $free_packtype(lanetype). |
| |
| free_vectype vectype |
| 1. Return {}. |
| |
| free_consttype consttype |
| 1. If consttype is numtype, then: |
| a. Return $free_numtype(consttype). |
| 2. Assert: Due to validation, consttype is vectype. |
| 3. Return $free_vectype(consttype). |
| |
| free_absheaptype absheaptype |
| 1. Return {}. |
| |
| free_typevar typevar |
| 1. If typevar is some _IDX, then: |
| a. Let (_IDX typeidx) be typevar. |
| b. Return $free_typeidx(typeidx). |
| 2. Assert: Due to validation, typevar is some REC. |
| 3. Return {}. |
| |
| free_heaptype heaptype |
| 1. If heaptype is absheaptype, then: |
| a. Return $free_absheaptype(heaptype). |
| 2. Assert: Due to validation, heaptype is typeuse. |
| 3. Return $free_typeuse(heaptype). |
| |
| free_reftype (REF null? heaptype) |
| 1. Return $free_heaptype(heaptype). |
| |
| free_typeuse typeuse |
| 1. If typeuse is typevar, then: |
| a. Return $free_typevar(typeuse). |
| 2. Assert: Due to validation, typeuse is deftype. |
| 3. Return $free_deftype(typeuse). |
| |
| free_valtype valtype |
| 1. If valtype is numtype, then: |
| a. Return $free_numtype(valtype). |
| 2. If valtype is vectype, then: |
| a. Return $free_vectype(valtype). |
| 3. If valtype is reftype, then: |
| a. Return $free_reftype(valtype). |
| 4. Assert: Due to validation, (valtype = BOT). |
| 5. Return {}. |
| |
| free_resulttype valtype* |
| 1. Return $free_list($free_valtype(valtype)*). |
| |
| free_storagetype storagetype |
| 1. If storagetype is valtype, then: |
| a. Return $free_valtype(storagetype). |
| 2. Assert: Due to validation, storagetype is packtype. |
| 3. Return $free_packtype(storagetype). |
| |
| free_fieldtype (mut? storagetype) |
| 1. Return $free_storagetype(storagetype). |
| |
| free_comptype comptype |
| 1. If comptype is some STRUCT, then: |
| a. Let (STRUCT fieldtype*) be comptype. |
| b. Return $free_list($free_fieldtype(fieldtype)*). |
| 2. If comptype is some ARRAY, then: |
| a. Let (ARRAY fieldtype) be comptype. |
| b. Return $free_fieldtype(fieldtype). |
| 3. Assert: Due to validation, comptype is some ->. |
| 4. Let (FUNC resulttype_1 -> resulttype_2) be comptype. |
| 5. Return $free_resulttype(resulttype_1) ++ $free_resulttype(resulttype_2). |
| |
| free_subtype (SUB final? typeuse* comptype) |
| 1. Return $free_list($free_typeuse(typeuse)*) ++ $free_comptype(comptype). |
| |
| free_rectype (REC subtype*) |
| 1. Return $free_list($free_subtype(subtype)*). |
| |
| free_deftype (_DEF rectype n) |
| 1. Return $free_rectype(rectype). |
| |
| free_tagtype deftype |
| 1. Return $free_deftype(deftype). |
| |
| free_globaltype (mut? valtype) |
| 1. Return $free_valtype(valtype). |
| |
| free_memtype addrtype limits PAGE |
| 1. Return $free_addrtype(addrtype). |
| |
| free_tabletype (addrtype limits reftype) |
| 1. Return $free_addrtype(addrtype) ++ $free_reftype(reftype). |
| |
| free_datatype OK |
| 1. Return {}. |
| |
| free_elemtype reftype |
| 1. Return $free_reftype(reftype). |
| |
| free_externtype externtype |
| 1. If externtype is some TAG, then: |
| a. Let (TAG tagtype) be externtype. |
| b. Return $free_tagtype(tagtype). |
| 2. If externtype is some GLOBAL, then: |
| a. Let (GLOBAL globaltype) be externtype. |
| b. Return $free_globaltype(globaltype). |
| 3. If externtype is some MEM, then: |
| a. Let (MEM memtype) be externtype. |
| b. Return $free_memtype(memtype). |
| 4. If externtype is some TABLE, then: |
| a. Let (TABLE tabletype) be externtype. |
| b. Return $free_tabletype(tabletype). |
| 5. Assert: Due to validation, externtype is some FUNC. |
| 6. Let (FUNC typeuse) be externtype. |
| 7. Return $free_typeuse(typeuse). |
| |
| free_moduletype externtype_1* -> externtype_2* |
| 1. Return $free_list($free_externtype(externtype_1)*) ++ $free_list($free_externtype(externtype_2)*). |
| |
| dim Lnn X M |
| 1. Return M. |
| |
| lanetype Lnn X M |
| 1. Return Lnn. |
| |
| unpackshape Lnn X M |
| 1. Return $lunpack(Lnn). |
| |
| memarg0 |
| 1. Return { ALIGN: 0; OFFSET: 0 }. |
| |
| const consttype c |
| 1. If consttype is numtype, then: |
| a. Return (consttype.CONST c). |
| 2. Assert: Due to validation, consttype is vectype. |
| 3. Return (consttype.CONST c). |
| |
| free_shape lanetype X dim |
| 1. Return $free_lanetype(lanetype). |
| |
| free_blocktype blocktype |
| 1. If blocktype is some _RESULT, then: |
| a. Let (_RESULT valtype?) be blocktype. |
| b. Return $free_opt($free_valtype(valtype)?). |
| 2. Assert: Due to validation, blocktype is some _IDX. |
| 3. Let (_IDX typeidx) be blocktype. |
| 4. Return $free_typeidx(typeidx). |
| |
| free_catch catch |
| 1. If catch is some CATCH, then: |
| a. Let (CATCH tagidx labelidx) be catch. |
| b. Return $free_tagidx(tagidx) ++ $free_labelidx(labelidx). |
| 2. If catch is some CATCH_REF, then: |
| a. Let (CATCH_REF tagidx labelidx) be catch. |
| b. Return $free_tagidx(tagidx) ++ $free_labelidx(labelidx). |
| 3. If catch is some CATCH_ALL, then: |
| a. Let (CATCH_ALL labelidx) be catch. |
| b. Return $free_labelidx(labelidx). |
| 4. Assert: Due to validation, catch is some CATCH_ALL_REF. |
| 5. Let (CATCH_ALL_REF labelidx) be catch. |
| 6. Return $free_labelidx(labelidx). |
| |
| shift_labelidxs labelidx''* |
| 1. If (labelidx''* = []), then: |
| a. Return []. |
| 2. Let [labelidx_0] :: labelidx'* be labelidx''*. |
| 3. If (labelidx_0 = 0), then: |
| a. Return $shift_labelidxs(labelidx'*). |
| 4. Let [labelidx] :: labelidx'* be labelidx''*. |
| 5. Return [(labelidx - 1)] :: $shift_labelidxs(labelidx'*). |
| |
| free_instr instr' |
| 1. If (instr' = NOP), then: |
| a. Return {}. |
| 2. If (instr' = UNREACHABLE), then: |
| a. Return {}. |
| 3. If (instr' = DROP), then: |
| a. Return {}. |
| 4. If instr' is some SELECT, then: |
| a. Let (SELECT valtype*?) be instr'. |
| b. Return $free_opt($free_list($free_valtype(valtype)*)?). |
| 5. If instr' is some BLOCK, then: |
| a. Let (BLOCK blocktype instr*) be instr'. |
| b. Return $free_blocktype(blocktype) ++ $free_block(instr*). |
| 6. If instr' is some LOOP, then: |
| a. Let (LOOP blocktype instr*) be instr'. |
| b. Return $free_blocktype(blocktype) ++ $free_block(instr*). |
| 7. If instr' is some IF, then: |
| a. Let (IF blocktype instr_1* ELSE instr_2*) be instr'. |
| b. Return $free_blocktype(blocktype) ++ $free_block(instr_1*) ++ $free_block(instr_2*). |
| 8. If instr' is some BR, then: |
| a. Let (BR labelidx) be instr'. |
| b. Return $free_labelidx(labelidx). |
| 9. If instr' is some BR_IF, then: |
| a. Let (BR_IF labelidx) be instr'. |
| b. Return $free_labelidx(labelidx). |
| 10. If instr' is some BR_TABLE, then: |
| a. Let (BR_TABLE labelidx* labelidx'') be instr'. |
| b. Return $free_list($free_labelidx(labelidx)*) ++ $free_labelidx(labelidx''). |
| 11. If instr' is some BR_ON_NULL, then: |
| a. Let (BR_ON_NULL labelidx) be instr'. |
| b. Return $free_labelidx(labelidx). |
| 12. If instr' is some BR_ON_NON_NULL, then: |
| a. Let (BR_ON_NON_NULL labelidx) be instr'. |
| b. Return $free_labelidx(labelidx). |
| 13. If instr' is some BR_ON_CAST, then: |
| a. Let (BR_ON_CAST labelidx reftype_1 reftype_2) be instr'. |
| b. Return $free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2). |
| 14. If instr' is some BR_ON_CAST_FAIL, then: |
| a. Let (BR_ON_CAST_FAIL labelidx reftype_1 reftype_2) be instr'. |
| b. Return $free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2). |
| 15. If instr' is some CALL, then: |
| a. Let (CALL funcidx) be instr'. |
| b. Return $free_funcidx(funcidx). |
| 16. If instr' is some CALL_REF, then: |
| a. Let (CALL_REF typeuse) be instr'. |
| b. Return $free_typeuse(typeuse). |
| 17. If instr' is some CALL_INDIRECT, then: |
| a. Let (CALL_INDIRECT tableidx typeuse) be instr'. |
| b. Return $free_tableidx(tableidx) ++ $free_typeuse(typeuse). |
| 18. If (instr' = RETURN), then: |
| a. Return {}. |
| 19. If instr' is some RETURN_CALL, then: |
| a. Let (RETURN_CALL funcidx) be instr'. |
| b. Return $free_funcidx(funcidx). |
| 20. If instr' is some RETURN_CALL_REF, then: |
| a. Let (RETURN_CALL_REF typeuse) be instr'. |
| b. Return $free_typeuse(typeuse). |
| 21. If instr' is some RETURN_CALL_INDIRECT, then: |
| a. Let (RETURN_CALL_INDIRECT tableidx typeuse) be instr'. |
| b. Return $free_tableidx(tableidx) ++ $free_typeuse(typeuse). |
| 22. If instr' is some THROW, then: |
| a. Let (THROW tagidx) be instr'. |
| b. Return $free_tagidx(tagidx). |
| 23. If (instr' = THROW_REF), then: |
| a. Return {}. |
| 24. If instr' is some TRY_TABLE, then: |
| a. Let (TRY_TABLE blocktype catch* instr*) be instr'. |
| b. Return $free_blocktype(blocktype) ++ $free_list($free_catch(catch)*) ++ $free_list($free_instr(instr)*). |
| 25. If instr' is some CONST, then: |
| a. Let (numtype.CONST numlit) be instr'. |
| b. Return $free_numtype(numtype). |
| 26. If instr' is some UNOP, then: |
| a. Let (UNOP numtype unop) be instr'. |
| b. Return $free_numtype(numtype). |
| 27. If instr' is some BINOP, then: |
| a. Let (BINOP numtype binop) be instr'. |
| b. Return $free_numtype(numtype). |
| 28. If instr' is some TESTOP, then: |
| a. Let (TESTOP numtype testop) be instr'. |
| b. Return $free_numtype(numtype). |
| 29. If instr' is some RELOP, then: |
| a. Let (RELOP numtype relop) be instr'. |
| b. Return $free_numtype(numtype). |
| 30. If instr' is some CVTOP, then: |
| a. Let (CVTOP numtype_1 numtype_2 cvtop) be instr'. |
| b. Return $free_numtype(numtype_1) ++ $free_numtype(numtype_2). |
| 31. If instr' is some VCONST, then: |
| a. Let (vectype.CONST veclit) be instr'. |
| b. Return $free_vectype(vectype). |
| 32. If instr' is some VVUNOP, then: |
| a. Let (VVUNOP vectype vvunop) be instr'. |
| b. Return $free_vectype(vectype). |
| 33. If instr' is some VVBINOP, then: |
| a. Let (VVBINOP vectype vvbinop) be instr'. |
| b. Return $free_vectype(vectype). |
| 34. If instr' is some VVTERNOP, then: |
| a. Let (VVTERNOP vectype vvternop) be instr'. |
| b. Return $free_vectype(vectype). |
| 35. If instr' is some VVTESTOP, then: |
| a. Let (VVTESTOP vectype vvtestop) be instr'. |
| b. Return $free_vectype(vectype). |
| 36. If instr' is some VUNOP, then: |
| a. Let (VUNOP shape vunop) be instr'. |
| b. Return $free_shape(shape). |
| 37. If instr' is some VBINOP, then: |
| a. Let (VBINOP shape vbinop) be instr'. |
| b. Return $free_shape(shape). |
| 38. If instr' is some VTERNOP, then: |
| a. Let (VTERNOP shape vternop) be instr'. |
| b. Return $free_shape(shape). |
| 39. If instr' is some VTESTOP, then: |
| a. Let (VTESTOP shape vtestop) be instr'. |
| b. Return $free_shape(shape). |
| 40. If instr' is some VRELOP, then: |
| a. Let (VRELOP shape vrelop) be instr'. |
| b. Return $free_shape(shape). |
| 41. If instr' is some VSHIFTOP, then: |
| a. Let (VSHIFTOP ishape vshiftop) be instr'. |
| b. Return $free_shape(ishape). |
| 42. If instr' is some VBITMASK, then: |
| a. Let (VBITMASK ishape) be instr'. |
| b. Return $free_shape(ishape). |
| 43. If instr' is some VSWIZZLOP, then: |
| a. Let (VSWIZZLOP bshape vswizzlop) be instr'. |
| b. Return $free_shape(bshape). |
| 44. If instr' is some VSHUFFLE, then: |
| a. Let (VSHUFFLE bshape laneidx*) be instr'. |
| b. Return $free_shape(bshape). |
| 45. If instr' is some VEXTUNOP, then: |
| a. Let (VEXTUNOP ishape_1 ishape_2 vextunop) be instr'. |
| b. Return $free_shape(ishape_1) ++ $free_shape(ishape_2). |
| 46. If instr' is some VEXTBINOP, then: |
| a. Let (VEXTBINOP ishape_1 ishape_2 vextbinop) be instr'. |
| b. Return $free_shape(ishape_1) ++ $free_shape(ishape_2). |
| 47. If instr' is some VEXTTERNOP, then: |
| a. Let (VEXTTERNOP ishape_1 ishape_2 vextternop) be instr'. |
| b. Return $free_shape(ishape_1) ++ $free_shape(ishape_2). |
| 48. If instr' is some VNARROW, then: |
| a. Let (VNARROW ishape_1 ishape_2 sx) be instr'. |
| b. Return $free_shape(ishape_1) ++ $free_shape(ishape_2). |
| 49. If instr' is some VCVTOP, then: |
| a. Let (VCVTOP shape_1 shape_2 vcvtop) be instr'. |
| b. Return $free_shape(shape_1) ++ $free_shape(shape_2). |
| 50. If instr' is some VSPLAT, then: |
| a. Let (VSPLAT shape) be instr'. |
| b. Return $free_shape(shape). |
| 51. If instr' is some VEXTRACT_LANE, then: |
| a. Let (VEXTRACT_LANE shape sx? laneidx) be instr'. |
| b. Return $free_shape(shape). |
| 52. If instr' is some VREPLACE_LANE, then: |
| a. Let (VREPLACE_LANE shape laneidx) be instr'. |
| b. Return $free_shape(shape). |
| 53. If instr' is some REF.NULL, then: |
| a. Let (REF.NULL heaptype) be instr'. |
| b. Return $free_heaptype(heaptype). |
| 54. If (instr' = REF.IS_NULL), then: |
| a. Return {}. |
| 55. If (instr' = REF.AS_NON_NULL), then: |
| a. Return {}. |
| 56. If (instr' = REF.EQ), then: |
| a. Return {}. |
| 57. If instr' is some REF.TEST, then: |
| a. Let (REF.TEST reftype) be instr'. |
| b. Return $free_reftype(reftype). |
| 58. If instr' is some REF.CAST, then: |
| a. Let (REF.CAST reftype) be instr'. |
| b. Return $free_reftype(reftype). |
| 59. If instr' is some REF.FUNC, then: |
| a. Let (REF.FUNC funcidx) be instr'. |
| b. Return $free_funcidx(funcidx). |
| 60. If (instr' = REF.I31), then: |
| a. Return {}. |
| 61. If instr' is some I31.GET, then: |
| a. Return {}. |
| 62. If instr' is some STRUCT.NEW, then: |
| a. Let (STRUCT.NEW typeidx) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 63. If instr' is some STRUCT.NEW_DEFAULT, then: |
| a. Let (STRUCT.NEW_DEFAULT typeidx) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 64. If instr' is some STRUCT.GET, then: |
| a. Let (STRUCT.GET sx? typeidx u32) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 65. If instr' is some STRUCT.SET, then: |
| a. Let (STRUCT.SET typeidx u32) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 66. If instr' is some ARRAY.NEW, then: |
| a. Let (ARRAY.NEW typeidx) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 67. If instr' is some ARRAY.NEW_DEFAULT, then: |
| a. Let (ARRAY.NEW_DEFAULT typeidx) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 68. If instr' is some ARRAY.NEW_FIXED, then: |
| a. Let (ARRAY.NEW_FIXED typeidx u32) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 69. If instr' is some ARRAY.NEW_DATA, then: |
| a. Let (ARRAY.NEW_DATA typeidx dataidx) be instr'. |
| b. Return $free_typeidx(typeidx) ++ $free_dataidx(dataidx). |
| 70. If instr' is some ARRAY.NEW_ELEM, then: |
| a. Let (ARRAY.NEW_ELEM typeidx elemidx) be instr'. |
| b. Return $free_typeidx(typeidx) ++ $free_elemidx(elemidx). |
| 71. If instr' is some ARRAY.GET, then: |
| a. Let (ARRAY.GET sx? typeidx) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 72. If instr' is some ARRAY.SET, then: |
| a. Let (ARRAY.SET typeidx) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 73. If (instr' = ARRAY.LEN), then: |
| a. Return {}. |
| 74. If instr' is some ARRAY.FILL, then: |
| a. Let (ARRAY.FILL typeidx) be instr'. |
| b. Return $free_typeidx(typeidx). |
| 75. If instr' is some ARRAY.COPY, then: |
| a. Let (ARRAY.COPY typeidx_1 typeidx_2) be instr'. |
| b. Return $free_typeidx(typeidx_1) ++ $free_typeidx(typeidx_2). |
| 76. If instr' is some ARRAY.INIT_DATA, then: |
| a. Let (ARRAY.INIT_DATA typeidx dataidx) be instr'. |
| b. Return $free_typeidx(typeidx) ++ $free_dataidx(dataidx). |
| 77. If instr' is some ARRAY.INIT_ELEM, then: |
| a. Let (ARRAY.INIT_ELEM typeidx elemidx) be instr'. |
| b. Return $free_typeidx(typeidx) ++ $free_elemidx(elemidx). |
| 78. If (instr' = EXTERN.CONVERT_ANY), then: |
| a. Return {}. |
| 79. If (instr' = ANY.CONVERT_EXTERN), then: |
| a. Return {}. |
| 80. If instr' is some LOCAL.GET, then: |
| a. Let (LOCAL.GET localidx) be instr'. |
| b. Return $free_localidx(localidx). |
| 81. If instr' is some LOCAL.SET, then: |
| a. Let (LOCAL.SET localidx) be instr'. |
| b. Return $free_localidx(localidx). |
| 82. If instr' is some LOCAL.TEE, then: |
| a. Let (LOCAL.TEE localidx) be instr'. |
| b. Return $free_localidx(localidx). |
| 83. If instr' is some GLOBAL.GET, then: |
| a. Let (GLOBAL.GET globalidx) be instr'. |
| b. Return $free_globalidx(globalidx). |
| 84. If instr' is some GLOBAL.SET, then: |
| a. Let (GLOBAL.SET globalidx) be instr'. |
| b. Return $free_globalidx(globalidx). |
| 85. If instr' is some TABLE.GET, then: |
| a. Let (TABLE.GET tableidx) be instr'. |
| b. Return $free_tableidx(tableidx). |
| 86. If instr' is some TABLE.SET, then: |
| a. Let (TABLE.SET tableidx) be instr'. |
| b. Return $free_tableidx(tableidx). |
| 87. If instr' is some TABLE.SIZE, then: |
| a. Let (TABLE.SIZE tableidx) be instr'. |
| b. Return $free_tableidx(tableidx). |
| 88. If instr' is some TABLE.GROW, then: |
| a. Let (TABLE.GROW tableidx) be instr'. |
| b. Return $free_tableidx(tableidx). |
| 89. If instr' is some TABLE.FILL, then: |
| a. Let (TABLE.FILL tableidx) be instr'. |
| b. Return $free_tableidx(tableidx). |
| 90. If instr' is some TABLE.COPY, then: |
| a. Let (TABLE.COPY tableidx_1 tableidx_2) be instr'. |
| b. Return $free_tableidx(tableidx_1) ++ $free_tableidx(tableidx_2). |
| 91. If instr' is some TABLE.INIT, then: |
| a. Let (TABLE.INIT tableidx elemidx) be instr'. |
| b. Return $free_tableidx(tableidx) ++ $free_elemidx(elemidx). |
| 92. If instr' is some ELEM.DROP, then: |
| a. Let (ELEM.DROP elemidx) be instr'. |
| b. Return $free_elemidx(elemidx). |
| 93. If instr' is some LOAD, then: |
| a. Let (LOAD numtype loadop? memidx memarg) be instr'. |
| b. Return $free_numtype(numtype) ++ $free_memidx(memidx). |
| 94. If instr' is some STORE, then: |
| a. Let (STORE numtype storeop? memidx memarg) be instr'. |
| b. Return $free_numtype(numtype) ++ $free_memidx(memidx). |
| 95. If instr' is some VLOAD, then: |
| a. Let (VLOAD vectype vloadop? memidx memarg) be instr'. |
| b. Return $free_vectype(vectype) ++ $free_memidx(memidx). |
| 96. If instr' is some VLOAD_LANE, then: |
| a. Let (VLOAD_LANE vectype sz memidx memarg laneidx) be instr'. |
| b. Return $free_vectype(vectype) ++ $free_memidx(memidx). |
| 97. If instr' is some VSTORE, then: |
| a. Let (VSTORE vectype memidx memarg) be instr'. |
| b. Return $free_vectype(vectype) ++ $free_memidx(memidx). |
| 98. If instr' is some VSTORE_LANE, then: |
| a. Let (VSTORE_LANE vectype sz memidx memarg laneidx) be instr'. |
| b. Return $free_vectype(vectype) ++ $free_memidx(memidx). |
| 99. If instr' is some MEMORY.SIZE, then: |
| a. Let (MEMORY.SIZE memidx) be instr'. |
| b. Return $free_memidx(memidx). |
| 100. If instr' is some MEMORY.GROW, then: |
| a. Let (MEMORY.GROW memidx) be instr'. |
| b. Return $free_memidx(memidx). |
| 101. If instr' is some MEMORY.FILL, then: |
| a. Let (MEMORY.FILL memidx) be instr'. |
| b. Return $free_memidx(memidx). |
| 102. If instr' is some MEMORY.COPY, then: |
| a. Let (MEMORY.COPY memidx_1 memidx_2) be instr'. |
| b. Return $free_memidx(memidx_1) ++ $free_memidx(memidx_2). |
| 103. If instr' is some MEMORY.INIT, then: |
| a. Let (MEMORY.INIT memidx dataidx) be instr'. |
| b. Return $free_memidx(memidx) ++ $free_dataidx(dataidx). |
| 104. Assert: Due to validation, instr' is some DATA.DROP. |
| 105. Let (DATA.DROP dataidx) be instr'. |
| 106. Return $free_dataidx(dataidx). |
| |
| free_block instr* |
| 1. Let free be $free_list($free_instr(instr)*). |
| 2. Return free with .LABELS replaced by $shift_labelidxs(free.LABELS). |
| |
| free_expr instr* |
| 1. Return $free_list($free_instr(instr)*). |
| |
| free_type (TYPE rectype) |
| 1. Return $free_rectype(rectype). |
| |
| free_tag (TAG tagtype) |
| 1. Return $free_tagtype(tagtype). |
| |
| free_global (GLOBAL globaltype expr) |
| 1. Return $free_globaltype(globaltype) ++ $free_expr(expr). |
| |
| free_mem (MEMORY memtype) |
| 1. Return $free_memtype(memtype). |
| |
| free_table (TABLE tabletype expr) |
| 1. Return $free_tabletype(tabletype) ++ $free_expr(expr). |
| |
| free_local (LOCAL t) |
| 1. Return $free_valtype(t). |
| |
| free_func (FUNC typeidx local* expr) |
| 1. Return $free_typeidx(typeidx) ++ $free_list($free_local(local)*) ++ $free_block(expr) with .LOCALS replaced by []. |
| |
| free_datamode datamode |
| 1. If datamode is some ACTIVE, then: |
| a. Let (ACTIVE memidx expr) be datamode. |
| b. Return $free_memidx(memidx) ++ $free_expr(expr). |
| 2. Assert: Due to validation, (datamode = PASSIVE). |
| 3. Return {}. |
| |
| free_data (DATA byte* datamode) |
| 1. Return $free_datamode(datamode). |
| |
| free_elemmode elemmode |
| 1. If elemmode is some ACTIVE, then: |
| a. Let (ACTIVE tableidx expr) be elemmode. |
| b. Return $free_tableidx(tableidx) ++ $free_expr(expr). |
| 2. If (elemmode = PASSIVE), then: |
| a. Return {}. |
| 3. Assert: Due to validation, (elemmode = DECLARE). |
| 4. Return {}. |
| |
| free_elem (ELEM reftype expr* elemmode) |
| 1. Return $free_reftype(reftype) ++ $free_list($free_expr(expr)*) ++ $free_elemmode(elemmode). |
| |
| free_start (START funcidx) |
| 1. Return $free_funcidx(funcidx). |
| |
| free_import (IMPORT name_1 name_2 externtype) |
| 1. Return $free_externtype(externtype). |
| |
| free_export (EXPORT name externidx) |
| 1. Return $free_externidx(externidx). |
| |
| free_module (MODULE type* import* tag* global* mem* table* func* data* elem* start? export*) |
| 1. Return $free_list($free_type(type)*) ++ $free_list($free_tag(tag)*) ++ $free_list($free_global(global)*) ++ $free_list($free_mem(mem)*) ++ $free_list($free_table(table)*) ++ $free_list($free_func(func)*) ++ $free_list($free_data(data)*) ++ $free_list($free_elem(elem)*) ++ $free_opt($free_start(start)?) ++ $free_list($free_import(import)*) ++ $free_list($free_export(export)*). |
| |
| funcidx_module module |
| 1. Return $free_module(module).FUNCS. |
| |
| dataidx_funcs func* |
| 1. Return $free_list($free_func(func)*).DATAS. |
| |
| with_locals C localidx* localtype* |
| 1. If (localtype* = []), then: |
| a. Assert: Due to validation, (localidx* = []). |
| b. Return C. |
| 2. Else: |
| a. Let [lct_1] :: lct* be localtype*. |
| b. Assert: Due to validation, (|localidx*| >= 1). |
| c. Let [x_1] :: x* be localidx*. |
| d. Return $with_locals(C with .LOCALS[x_1] replaced by lct_1, x*, lct*). |
| |
| clos_deftypes deftype* |
| 1. If (deftype* = []), then: |
| a. Return []. |
| 2. Let dt* :: [dt_n] be deftype*. |
| 3. Let dt'* be $clos_deftypes(dt*). |
| 4. Return dt'* :: [$subst_all_deftype(dt_n, dt'*)]. |
| |
| clos_valtype C t |
| 1. Let dt* be $clos_deftypes(C.TYPES). |
| 2. Return $subst_all_valtype(t, dt*). |
| |
| clos_deftype C dt |
| 1. Let dt'* be $clos_deftypes(C.TYPES). |
| 2. Return $subst_all_deftype(dt, dt'*). |
| |
| clos_tagtype C jt |
| 1. Let dt* be $clos_deftypes(C.TYPES). |
| 2. Return $subst_all_tagtype(jt, dt*). |
| |
| clos_externtype C xt |
| 1. Let dt* be $clos_deftypes(C.TYPES). |
| 2. Return $subst_all_externtype(xt, dt*). |
| |
| clos_moduletype C mmt |
| 1. Let dt* be $clos_deftypes(C.TYPES). |
| 2. Return $subst_all_moduletype(mmt, dt*). |
| |
| before typeuse i |
| 1. If typeuse is not REC, then: |
| a. Return true. |
| 2. Let (REC j) be typeuse. |
| 3. Return (j < i). |
| |
| unrollht_ C heaptype |
| 1. If heaptype is deftype, then: |
| a. Return $unrolldt(heaptype). |
| 2. If heaptype is some _IDX, then: |
| a. Let (_IDX typeidx) be heaptype. |
| b. Return $unrolldt(C.TYPES[typeidx]). |
| 3. Assert: Due to validation, heaptype is some REC. |
| 4. Let (REC i) be heaptype. |
| 5. Return C.RECS[i]. |
| |
| default_ valtype |
| 1. If valtype is Inn, then: |
| a. Return ?((valtype.CONST 0)). |
| 2. If valtype is Fnn, then: |
| a. Return ?((valtype.CONST $fzero($size(valtype)))). |
| 3. If valtype is Vnn, then: |
| a. Return ?((valtype.CONST 0)). |
| 4. Assert: Due to validation, valtype is some REF. |
| 5. Let (REF NULL_0? ht) be valtype. |
| 6. If (NULL_0? = ?(NULL)), then: |
| a. Return ?(REF.NULL_ADDR). |
| 7. Assert: Due to validation, NULL_0? is not defined. |
| 8. Return ?(). |
| |
| is_packtype zt |
| 1. Return (zt =/= $unpack(zt)). |
| |
| funcidx_nonfuncs (global* mem* table* elem* start? export*) |
| 1. Return $funcidx_module((MODULE [] [] [] global* mem* table* [] [] elem* start? export*)). |
| |
| relaxed2 i `X X_1 X_2 |
| 1. If $ND(), then: |
| a. Return [X_1, X_2][i]. |
| 2. Return [X_1, X_2][0]. |
| |
| relaxed4 i `X X_1 X_2 X_3 X_4 |
| 1. If $ND(), then: |
| a. Return [X_1, X_2, X_3, X_4][i]. |
| 2. Return [X_1, X_2, X_3, X_4][0]. |
| |
| signed_ N i |
| 1. If (i < (2 ^ (N - 1))), then: |
| a. Return i. |
| 2. Assert: Due to validation, ((2 ^ (N - 1)) <= i). |
| 3. Assert: Due to validation, (i < (2 ^ N)). |
| 4. Return (i - (2 ^ N)). |
| |
| inv_signed_ N i |
| 1. If ((0 <= i) /\ (i < (2 ^ (N - 1)))), then: |
| a. Return i. |
| 2. Assert: Due to validation, ((- (2 ^ (N - 1))) <= i). |
| 3. Assert: Due to validation, (i < 0). |
| 4. Return (i + (2 ^ N)). |
| |
| sx storagetype |
| 1. If storagetype is consttype, then: |
| a. Return ?(). |
| 2. Assert: Due to validation, storagetype is packtype. |
| 3. Return ?(S). |
| |
| zero lanetype |
| 1. If lanetype is Jnn, then: |
| a. Return 0. |
| 2. Assert: Due to validation, lanetype is Fnn. |
| 3. Return $fzero($size(lanetype)). |
| |
| bool b |
| 1. If (b = false), then: |
| a. Return 0. |
| 2. Assert: Due to validation, (b = true). |
| 3. Return 1. |
| |
| sat_u_ N i |
| 1. If (i < 0), then: |
| a. Return 0. |
| 2. If (i > ((2 ^ N) - 1)), then: |
| a. Return ((2 ^ N) - 1). |
| 3. Return i. |
| |
| sat_s_ N i |
| 1. If (i < (- (2 ^ (N - 1)))), then: |
| a. Return (- (2 ^ (N - 1))). |
| 2. If (i > ((2 ^ (N - 1)) - 1)), then: |
| a. Return ((2 ^ (N - 1)) - 1). |
| 3. Return i. |
| |
| ineg_ N i_1 |
| 1. Return (((2 ^ N) - i_1) \ (2 ^ N)). |
| |
| iabs_ N i_1 |
| 1. If ($signed_(N, i_1) >= 0), then: |
| a. Return i_1. |
| 2. Return $ineg_(N, i_1). |
| |
| iextend_ N K sx i |
| 1. If (sx = U), then: |
| a. Return (i \ (2 ^ K)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $inv_signed_(N, $signed_(K, (i \ (2 ^ K)))). |
| |
| iadd_ N i_1 i_2 |
| 1. Return ((i_1 + i_2) \ (2 ^ N)). |
| |
| isub_ N i_1 i_2 |
| 1. Return ((((2 ^ N) + i_1) - i_2) \ (2 ^ N)). |
| |
| imul_ N i_1 i_2 |
| 1. Return ((i_1 * i_2) \ (2 ^ N)). |
| |
| idiv_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_2 = 0), then: |
| 1) Return ?(). |
| b. Return ?($truncz((i_1 / i_2))). |
| 2. Assert: Due to validation, (sx = S). |
| 3. If (i_2 = 0), then: |
| a. Return ?(). |
| 4. If (($signed_(N, i_1) / $signed_(N, i_2)) = (2 ^ (N - 1))), then: |
| a. Return ?(). |
| 5. Return ?($inv_signed_(N, $truncz(($signed_(N, i_1) / $signed_(N, i_2))))). |
| |
| irem_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_2 = 0), then: |
| 1) Return ?(). |
| b. Return ?((i_1 - (i_2 * $truncz((i_1 / i_2))))). |
| 2. Assert: Due to validation, (sx = S). |
| 3. If (i_2 = 0), then: |
| a. Return ?(). |
| 4. Let j_1 be $signed_(N, i_1). |
| 5. Let j_2 be $signed_(N, i_2). |
| 6. Return ?($inv_signed_(N, (j_1 - (j_2 * $truncz((j_1 / j_2)))))). |
| |
| imin_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_1 <= i_2), then: |
| 1) Return i_1. |
| b. Return i_2. |
| 2. Assert: Due to validation, (sx = S). |
| 3. If ($signed_(N, i_1) <= $signed_(N, i_2)), then: |
| a. Return i_1. |
| 4. Return i_2. |
| |
| imax_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. If (i_1 >= i_2), then: |
| 1) Return i_1. |
| b. Return i_2. |
| 2. Assert: Due to validation, (sx = S). |
| 3. If ($signed_(N, i_1) >= $signed_(N, i_2)), then: |
| a. Return i_1. |
| 4. Return i_2. |
| |
| iadd_sat_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $sat_u_(N, (i_1 + i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $inv_signed_(N, $sat_s_(N, ($signed_(N, i_1) + $signed_(N, i_2)))). |
| |
| isub_sat_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $sat_u_(N, (i_1 - i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $inv_signed_(N, $sat_s_(N, ($signed_(N, i_1) - $signed_(N, i_2)))). |
| |
| ieqz_ N i_1 |
| 1. Return $bool((i_1 = 0)). |
| |
| inez_ N i_1 |
| 1. Return $bool((i_1 =/= 0)). |
| |
| ieq_ N i_1 i_2 |
| 1. Return $bool((i_1 = i_2)). |
| |
| ine_ N i_1 i_2 |
| 1. Return $bool((i_1 =/= i_2)). |
| |
| ilt_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 < i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) < $signed_(N, i_2))). |
| |
| igt_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 > i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) > $signed_(N, i_2))). |
| |
| ile_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 <= i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) <= $signed_(N, i_2))). |
| |
| ige_ N sx i_1 i_2 |
| 1. If (sx = U), then: |
| a. Return $bool((i_1 >= i_2)). |
| 2. Assert: Due to validation, (sx = S). |
| 3. Return $bool(($signed_(N, i_1) >= $signed_(N, i_2))). |
| |
| lpacknum_ lanetype c |
| 1. If lanetype is numtype, then: |
| a. Return c. |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return $wrap__($size($lunpack(lanetype)), $psize(lanetype), c). |
| |
| cpacknum_ storagetype c |
| 1. If storagetype is consttype, then: |
| a. Return c. |
| 2. Assert: Due to validation, storagetype is packtype. |
| 3. Return $wrap__($size($lunpack(storagetype)), $psize(storagetype), c). |
| |
| lunpacknum_ lanetype c |
| 1. If lanetype is numtype, then: |
| a. Return c. |
| 2. Assert: Due to validation, lanetype is packtype. |
| 3. Return $extend__($psize(lanetype), $size($lunpack(lanetype)), U, c). |
| |
| cunpacknum_ storagetype c |
| 1. If storagetype is consttype, then: |
| a. Return c. |
| 2. Assert: Due to validation, storagetype is packtype. |
| 3. Return $extend__($psize(storagetype), $size($lunpack(storagetype)), U, c). |
| |
| unop_ numtype unop_ i |
| 1. If numtype is Inn, then: |
| a. If (unop_ = CLZ), then: |
| 1) Return [$iclz_($sizenn(numtype), i)]. |
| b. If (unop_ = CTZ), then: |
| 1) Return [$ictz_($sizenn(numtype), i)]. |
| c. If (unop_ = POPCNT), then: |
| 1) Return [$ipopcnt_($sizenn(numtype), i)]. |
| d. If unop_ is some EXTEND, then: |
| 1) Let (EXTEND N) be unop_. |
| 2) Return [$iextend_($sizenn(numtype), N, S, i)]. |
| 2. Assert: Due to validation, numtype is Fnn. |
| 3. If (unop_ = ABS), then: |
| a. Return $fabs_($sizenn(numtype), i). |
| 4. If (unop_ = NEG), then: |
| a. Return $fneg_($sizenn(numtype), i). |
| 5. If (unop_ = SQRT), then: |
| a. Return $fsqrt_($sizenn(numtype), i). |
| 6. If (unop_ = CEIL), then: |
| a. Return $fceil_($sizenn(numtype), i). |
| 7. If (unop_ = FLOOR), then: |
| a. Return $ffloor_($sizenn(numtype), i). |
| 8. If (unop_ = TRUNC), then: |
| a. Return $ftrunc_($sizenn(numtype), i). |
| 9. Assert: Due to validation, (unop_ = NEAREST). |
| 10. Return $fnearest_($sizenn(numtype), i). |
| |
| binop_ numtype binop_ i_1 i_2 |
| 1. If numtype is Inn, then: |
| a. If (binop_ = ADD), then: |
| 1) Return [$iadd_($sizenn(numtype), i_1, i_2)]. |
| b. If (binop_ = SUB), then: |
| 1) Return [$isub_($sizenn(numtype), i_1, i_2)]. |
| c. If (binop_ = MUL), then: |
| 1) Return [$imul_($sizenn(numtype), i_1, i_2)]. |
| d. If binop_ is some DIV, then: |
| 1) Let (DIV sx) be binop_. |
| 2) Return $idiv_($sizenn(numtype), sx, i_1, i_2). |
| e. If binop_ is some REM, then: |
| 1) Let (REM sx) be binop_. |
| 2) Return $irem_($sizenn(numtype), sx, i_1, i_2). |
| f. If (binop_ = AND), then: |
| 1) Return [$iand_($sizenn(numtype), i_1, i_2)]. |
| g. If (binop_ = OR), then: |
| 1) Return [$ior_($sizenn(numtype), i_1, i_2)]. |
| h. If (binop_ = XOR), then: |
| 1) Return [$ixor_($sizenn(numtype), i_1, i_2)]. |
| i. If (binop_ = SHL), then: |
| 1) Return [$ishl_($sizenn(numtype), i_1, i_2)]. |
| j. If binop_ is some SHR, then: |
| 1) Let (SHR sx) be binop_. |
| 2) Return [$ishr_($sizenn(numtype), sx, i_1, i_2)]. |
| k. If (binop_ = ROTL), then: |
| 1) Return [$irotl_($sizenn(numtype), i_1, i_2)]. |
| l. If (binop_ = ROTR), then: |
| 1) Return [$irotr_($sizenn(numtype), i_1, i_2)]. |
| 2. Assert: Due to validation, numtype is Fnn. |
| 3. If (binop_ = ADD), then: |
| a. Return $fadd_($sizenn(numtype), i_1, i_2). |
| 4. If (binop_ = SUB), then: |
| a. Return $fsub_($sizenn(numtype), i_1, i_2). |
| 5. If (binop_ = MUL), then: |
| a. Return $fmul_($sizenn(numtype), i_1, i_2). |
| 6. If (binop_ = DIV), then: |
| a. Return $fdiv_($sizenn(numtype), i_1, i_2). |
| 7. If (binop_ = MIN), then: |
| a. Return $fmin_($sizenn(numtype), i_1, i_2). |
| 8. If (binop_ = MAX), then: |
| a. Return $fmax_($sizenn(numtype), i_1, i_2). |
| 9. Assert: Due to validation, (binop_ = COPYSIGN). |
| 10. Return $fcopysign_($sizenn(numtype), i_1, i_2). |
| |
| testop_ Inn EQZ i |
| 1. Return $ieqz_($sizenn(Inn), i). |
| |
| relop_ numtype relop_ i_1 i_2 |
| 1. If numtype is Inn, then: |
| a. If (relop_ = EQ), then: |
| 1) Return $ieq_($sizenn(numtype), i_1, i_2). |
| b. If (relop_ = NE), then: |
| 1) Return $ine_($sizenn(numtype), i_1, i_2). |
| c. If relop_ is some LT, then: |
| 1) Let (LT sx) be relop_. |
| 2) Return $ilt_($sizenn(numtype), sx, i_1, i_2). |
| d. If relop_ is some GT, then: |
| 1) Let (GT sx) be relop_. |
| 2) Return $igt_($sizenn(numtype), sx, i_1, i_2). |
| e. If relop_ is some LE, then: |
| 1) Let (LE sx) be relop_. |
| 2) Return $ile_($sizenn(numtype), sx, i_1, i_2). |
| f. If relop_ is some GE, then: |
| 1) Let (GE sx) be relop_. |
| 2) Return $ige_($sizenn(numtype), sx, i_1, i_2). |
| 2. Assert: Due to validation, numtype is Fnn. |
| 3. If (relop_ = EQ), then: |
| a. Return $feq_($sizenn(numtype), i_1, i_2). |
| 4. If (relop_ = NE), then: |
| a. Return $fne_($sizenn(numtype), i_1, i_2). |
| 5. If (relop_ = LT), then: |
| a. Return $flt_($sizenn(numtype), i_1, i_2). |
| 6. If (relop_ = GT), then: |
| a. Return $fgt_($sizenn(numtype), i_1, i_2). |
| 7. If (relop_ = LE), then: |
| a. Return $fle_($sizenn(numtype), i_1, i_2). |
| 8. Assert: Due to validation, (relop_ = GE). |
| 9. Return $fge_($sizenn(numtype), i_1, i_2). |
| |
| cvtop__ numtype numtype' cvtop__ i_1 |
| 1. If (numtype is Inn /\ numtype' is Inn), then: |
| a. If cvtop__ is some EXTEND, then: |
| 1) Let (EXTEND sx) be cvtop__. |
| 2) Return [$extend__($sizenn1(numtype), $sizenn2(numtype'), sx, i_1)]. |
| b. If (cvtop__ = WRAP), then: |
| 1) Return [$wrap__($sizenn1(numtype), $sizenn2(numtype'), i_1)]. |
| 2. If (numtype is Fnn /\ numtype' is Inn), then: |
| a. If cvtop__ is some TRUNC, then: |
| 1) Let (TRUNC sx) be cvtop__. |
| 2) Return $trunc__($sizenn1(numtype), $sizenn2(numtype'), sx, i_1). |
| b. If cvtop__ is some TRUNC_SAT, then: |
| 1) Let (TRUNC_SAT sx) be cvtop__. |
| 2) Return $trunc_sat__($sizenn1(numtype), $sizenn2(numtype'), sx, i_1). |
| 3. If (numtype is Inn /\ (numtype' is Fnn /\ cvtop__ is some CONVERT)), then: |
| a. Let (CONVERT sx) be cvtop__. |
| b. Return [$convert__($sizenn1(numtype), $sizenn2(numtype'), sx, i_1)]. |
| 4. If (numtype is Fnn /\ numtype' is Fnn), then: |
| a. If (cvtop__ = PROMOTE), then: |
| 1) Return $promote__($sizenn1(numtype), $sizenn2(numtype'), i_1). |
| b. If (cvtop__ = DEMOTE), then: |
| 1) Return $demote__($sizenn1(numtype), $sizenn2(numtype'), i_1). |
| 5. If (numtype is Inn /\ (numtype' is Fnn /\ ((cvtop__ = REINTERPRET) /\ ($size(numtype) = $size(numtype'))))), then: |
| a. Return [$reinterpret__(numtype, numtype', i_1)]. |
| 6. Assert: Due to validation, numtype is Fnn. |
| 7. Assert: Due to validation, numtype' is Inn. |
| 8. Assert: Due to validation, (cvtop__ = REINTERPRET). |
| 9. Assert: Due to validation, ($size(numtype) = $size(numtype')). |
| 10. Return [$reinterpret__(numtype, numtype', i_1)]. |
| |
| zeroop lanetype' X M_1 lanetype X M_2 vcvtop__ |
| 1. If lanetype' is Jnn, then: |
| a. If (lanetype is Jnn /\ vcvtop__ is some EXTEND), then: |
| 1) Return ?(). |
| b. If (lanetype is Fnn /\ vcvtop__ is some CONVERT), then: |
| 1) Return ?(). |
| 2. Assert: Due to validation, lanetype' is Fnn. |
| 3. If lanetype is Jnn, then: |
| a. If vcvtop__ is some TRUNC_SAT, then: |
| 1) Let (TRUNC_SAT sx zero?) be vcvtop__. |
| 2) Return zero?. |
| b. If vcvtop__ is some RELAXED_TRUNC, then: |
| 1) Let (RELAXED_TRUNC sx zero?) be vcvtop__. |
| 2) Return zero?. |
| 4. Assert: Due to validation, lanetype is Fnn. |
| 5. If vcvtop__ is some DEMOTE, then: |
| a. Let (DEMOTE zero) be vcvtop__. |
| b. Return ?(zero). |
| 6. Assert: Due to validation, (vcvtop__ = PROMOTELOW). |
| 7. Return ?(). |
| |
| halfop lanetype' X M_1 lanetype X M_2 vcvtop__ |
| 1. If lanetype' is Jnn, then: |
| a. If (lanetype is Jnn /\ vcvtop__ is some EXTEND), then: |
| 1) Let (EXTEND half sx) be vcvtop__. |
| 2) Return ?(half). |
| b. If (lanetype is Fnn /\ vcvtop__ is some CONVERT), then: |
| 1) Let (CONVERT half? sx) be vcvtop__. |
| 2) Return half?. |
| 2. Assert: Due to validation, lanetype' is Fnn. |
| 3. If lanetype is Jnn, then: |
| a. If vcvtop__ is some TRUNC_SAT, then: |
| 1) Return ?(). |
| b. If vcvtop__ is some RELAXED_TRUNC, then: |
| 1) Return ?(). |
| 4. Assert: Due to validation, lanetype is Fnn. |
| 5. If vcvtop__ is some DEMOTE, then: |
| a. Return ?(). |
| 6. Assert: Due to validation, (vcvtop__ = PROMOTELOW). |
| 7. Return ?(LOW). |
| |
| half half i j |
| 1. If (half = LOW), then: |
| a. Return i. |
| 2. Assert: Due to validation, (half = HIGH). |
| 3. Return j. |
| |
| iswizzle_lane_ N c* i |
| 1. If (i < |c*|), then: |
| a. Return c*[i]. |
| 2. Return 0. |
| |
| irelaxed_swizzle_lane_ N c* i |
| 1. If (i < |c*|), then: |
| a. Return c*[i]. |
| 2. If ($signed_(N, i) < 0), then: |
| a. Return 0. |
| 3. Return $relaxed2($R_swizzle(), `iN(N), 0, c*[(i \ |c*|)]). |
| |
| ivunop_ Jnn X M $f_ v_1 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c* be []. |
| 3. For each c_1 in c_1*, do: |
| a. Let c be $f_($lsizenn(Jnn), c_1). |
| b. Append c to the c*. |
| 4. Return [$inv_lanes_(Jnn X M, c*)]. |
| |
| fvunop_ Fnn X M $f_ v_1 |
| 1. Let c_1* be $lanes_(Fnn X M, v_1). |
| 2. Let c** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $f_($sizenn(Fnn), c_1)*). |
| 3. Return $inv_lanes_(Fnn X M, c*)*. |
| |
| ivbinop_ Jnn X M $f_ v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c* be []. |
| 4. For each c_1 in c_1* and c_2 in c_2*, do: |
| a. Let c be $f_($lsizenn(Jnn), c_1, c_2). |
| b. Append c to the c*. |
| 5. Return [$inv_lanes_(Jnn X M, c*)]. |
| |
| ivbinopsx_ Jnn X M $f_ sx v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c* be []. |
| 4. For each c_1 in c_1* and c_2 in c_2*, do: |
| a. Let c be $f_($lsizenn(Jnn), sx, c_1, c_2). |
| b. Append c to the c*. |
| 5. Return [$inv_lanes_(Jnn X M, c*)]. |
| |
| ivbinopsxnd_ Jnn X M $f_ sx v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c** be $setproduct_(`lane_((Jnn : Jnn <: lanetype)), $f_($lsizenn(Jnn), sx, c_1, c_2)*). |
| 4. Return $inv_lanes_(Jnn X M, c*)*. |
| |
| fvbinop_ Fnn X M $f_ v_1 v_2 |
| 1. Let c_1* be $lanes_(Fnn X M, v_1). |
| 2. Let c_2* be $lanes_(Fnn X M, v_2). |
| 3. Let c** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $f_($sizenn(Fnn), c_1, c_2)*). |
| 4. Return $inv_lanes_(Fnn X M, c*)*. |
| |
| ivternopnd_ Jnn X M $f_ v_1 v_2 v_3 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c_3* be $lanes_(Jnn X M, v_3). |
| 4. Let c** be $setproduct_(`lane_((Jnn : Jnn <: lanetype)), $f_($lsizenn(Jnn), c_1, c_2, c_3)*). |
| 5. Return $inv_lanes_(Jnn X M, c*)*. |
| |
| fvternop_ Fnn X M $f_ v_1 v_2 v_3 |
| 1. Let c_1* be $lanes_(Fnn X M, v_1). |
| 2. Let c_2* be $lanes_(Fnn X M, v_2). |
| 3. Let c_3* be $lanes_(Fnn X M, v_3). |
| 4. Let c** be $setproduct_(`lane_((Fnn : Fnn <: lanetype)), $f_($sizenn(Fnn), c_1, c_2, c_3)*). |
| 5. Return $inv_lanes_(Fnn X M, c*)*. |
| |
| ivrelop_ Jnn X M $f_ v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c* be []. |
| 4. For each c_1 in c_1* and c_2 in c_2*, do: |
| a. Let c be $extend__(1, $lsizenn(Jnn), S, $f_($lsizenn(Jnn), c_1, c_2)). |
| b. Append c to the c*. |
| 5. Return $inv_lanes_(Jnn X M, c*). |
| |
| ivrelopsx_ Jnn X M $f_ sx v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c* be []. |
| 4. For each c_1 in c_1* and c_2 in c_2*, do: |
| a. Let c be $extend__(1, $lsizenn(Jnn), S, $f_($lsizenn(Jnn), sx, c_1, c_2)). |
| b. Append c to the c*. |
| 5. Return $inv_lanes_(Jnn X M, c*). |
| |
| fvrelop_ Fnn X M $f_ v_1 v_2 |
| 1. Let c_1* be $lanes_(Fnn X M, v_1). |
| 2. Let c_2* be $lanes_(Fnn X M, v_2). |
| 3. Let Inn be $isize^-1($fsize(Fnn)). |
| 4. Let c* be []. |
| 5. For each c_1 in c_1* and c_2 in c_2*, do: |
| a. Let c be $extend__(1, $sizenn(Fnn), S, $f_($sizenn(Fnn), c_1, c_2)). |
| b. Append c to the c*. |
| 6. Return $inv_lanes_(Inn X M, c*). |
| |
| ivshiftop_ Jnn X M $f_ v_1 i |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c* be []. |
| 3. For each c_1 in c_1*, do: |
| a. Let c be $f_($lsizenn(Jnn), c_1, i). |
| b. Append c to the c*. |
| 4. Return $inv_lanes_(Jnn X M, c*). |
| |
| ivshiftopsx_ Jnn X M $f_ sx v_1 i |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c* be []. |
| 3. For each c_1 in c_1*, do: |
| a. Let c be $f_($lsizenn(Jnn), sx, c_1, i). |
| b. Append c to the c*. |
| 4. Return $inv_lanes_(Jnn X M, c*). |
| |
| ivbitmaskop_ Jnn X M v_1 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c be $ibits__1^-1(32, $ilt_($lsizenn(Jnn), S, c_1, 0)* :: 0^(32 - M)). |
| 3. Return $irev_(32, c). |
| |
| ivswizzlop_ Jnn X M $f_ v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c* be []. |
| 4. For each c_2 in c_2*, do: |
| a. Let c be $f_($lsizenn(Jnn), c_1*, c_2). |
| b. Append c to the c*. |
| 5. Return $inv_lanes_(Jnn X M, c*). |
| |
| ivshufflop_ Jnn X M i* v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn X M, v_1). |
| 2. Let c_2* be $lanes_(Jnn X M, v_2). |
| 3. Let c* be []. |
| 4. For each i in i*, do: |
| a. Let c be c_1* :: c_2*[i]. |
| b. Append c to the c*. |
| 5. Return $inv_lanes_(Jnn X M, c*). |
| |
| vvunop_ Vnn NOT v |
| 1. Return [$inot_($vsizenn(Vnn), v)]. |
| |
| vvbinop_ Vnn vvbinop v_1 v_2 |
| 1. If (vvbinop = AND), then: |
| a. Return [$iand_($vsizenn(Vnn), v_1, v_2)]. |
| 2. If (vvbinop = ANDNOT), then: |
| a. Return [$iandnot_($vsizenn(Vnn), v_1, v_2)]. |
| 3. If (vvbinop = OR), then: |
| a. Return [$ior_($vsizenn(Vnn), v_1, v_2)]. |
| 4. Assert: Due to validation, (vvbinop = XOR). |
| 5. Return [$ixor_($vsizenn(Vnn), v_1, v_2)]. |
| |
| vvternop_ Vnn BITSELECT v_1 v_2 v_3 |
| 1. Return [$ibitselect_($vsizenn(Vnn), v_1, v_2, v_3)]. |
| |
| vunop_ lanetype X M vunop_ v |
| 1. If lanetype is Fnn, then: |
| a. If (vunop_ = ABS), then: |
| 1) Return $fvunop_(lanetype X M, $fabs_, v). |
| b. If (vunop_ = NEG), then: |
| 1) Return $fvunop_(lanetype X M, $fneg_, v). |
| c. If (vunop_ = SQRT), then: |
| 1) Return $fvunop_(lanetype X M, $fsqrt_, v). |
| d. If (vunop_ = CEIL), then: |
| 1) Return $fvunop_(lanetype X M, $fceil_, v). |
| e. If (vunop_ = FLOOR), then: |
| 1) Return $fvunop_(lanetype X M, $ffloor_, v). |
| f. If (vunop_ = TRUNC), then: |
| 1) Return $fvunop_(lanetype X M, $ftrunc_, v). |
| g. If (vunop_ = NEAREST), then: |
| 1) Return $fvunop_(lanetype X M, $fnearest_, v). |
| 2. Assert: Due to validation, lanetype is Jnn. |
| 3. If (vunop_ = ABS), then: |
| a. Return $ivunop_(lanetype X M, $iabs_, v). |
| 4. If (vunop_ = NEG), then: |
| a. Return $ivunop_(lanetype X M, $ineg_, v). |
| 5. Assert: Due to validation, (vunop_ = POPCNT). |
| 6. Return $ivunop_(lanetype X M, $ipopcnt_, v). |
| |
| vbinop_ lanetype X M vbinop_ v_1 v_2 |
| 1. If lanetype is Jnn, then: |
| a. If (vbinop_ = ADD), then: |
| 1) Return $ivbinop_(lanetype X M, $iadd_, v_1, v_2). |
| b. If (vbinop_ = SUB), then: |
| 1) Return $ivbinop_(lanetype X M, $isub_, v_1, v_2). |
| c. If (vbinop_ = MUL), then: |
| 1) Return $ivbinop_(lanetype X M, $imul_, v_1, v_2). |
| d. If vbinop_ is some ADD_SAT, then: |
| 1) Let (ADD_SAT sx) be vbinop_. |
| 2) Return $ivbinopsx_(lanetype X M, $iadd_sat_, sx, v_1, v_2). |
| e. If vbinop_ is some SUB_SAT, then: |
| 1) Let (SUB_SAT sx) be vbinop_. |
| 2) Return $ivbinopsx_(lanetype X M, $isub_sat_, sx, v_1, v_2). |
| f. If vbinop_ is some MIN, then: |
| 1) Let (MIN sx) be vbinop_. |
| 2) Return $ivbinopsx_(lanetype X M, $imin_, sx, v_1, v_2). |
| g. If vbinop_ is some MAX, then: |
| 1) Let (MAX sx) be vbinop_. |
| 2) Return $ivbinopsx_(lanetype X M, $imax_, sx, v_1, v_2). |
| h. If (vbinop_ = AVGRU), then: |
| 1) Return $ivbinopsx_(lanetype X M, $iavgr_, U, v_1, v_2). |
| i. If (vbinop_ = Q15MULR_SATS), then: |
| 1) Return $ivbinopsx_(lanetype X M, $iq15mulr_sat_, S, v_1, v_2). |
| j. If (vbinop_ = RELAXED_Q15MULRS), then: |
| 1) Return $ivbinopsxnd_(lanetype X M, $irelaxed_q15mulr_, S, v_1, v_2). |
| 2. Assert: Due to validation, lanetype is Fnn. |
| 3. If (vbinop_ = ADD), then: |
| a. Return $fvbinop_(lanetype X M, $fadd_, v_1, v_2). |
| 4. If (vbinop_ = SUB), then: |
| a. Return $fvbinop_(lanetype X M, $fsub_, v_1, v_2). |
| 5. If (vbinop_ = MUL), then: |
| a. Return $fvbinop_(lanetype X M, $fmul_, v_1, v_2). |
| 6. If (vbinop_ = DIV), then: |
| a. Return $fvbinop_(lanetype X M, $fdiv_, v_1, v_2). |
| 7. If (vbinop_ = MIN), then: |
| a. Return $fvbinop_(lanetype X M, $fmin_, v_1, v_2). |
| 8. If (vbinop_ = MAX), then: |
| a. Return $fvbinop_(lanetype X M, $fmax_, v_1, v_2). |
| 9. If (vbinop_ = PMIN), then: |
| a. Return $fvbinop_(lanetype X M, $fpmin_, v_1, v_2). |
| 10. If (vbinop_ = PMAX), then: |
| a. Return $fvbinop_(lanetype X M, $fpmax_, v_1, v_2). |
| 11. If (vbinop_ = RELAXED_MIN), then: |
| a. Return $fvbinop_(lanetype X M, $frelaxed_min_, v_1, v_2). |
| 12. Assert: Due to validation, (vbinop_ = RELAXED_MAX). |
| 13. Return $fvbinop_(lanetype X M, $frelaxed_max_, v_1, v_2). |
| |
| vternop_ lanetype X M vternop_ v_1 v_2 v_3 |
| 1. If (lanetype is Jnn /\ (vternop_ = RELAXED_LANESELECT)), then: |
| a. Return $ivternopnd_(lanetype X M, $irelaxed_laneselect_, v_1, v_2, v_3). |
| 2. Assert: Due to validation, lanetype is Fnn. |
| 3. If (vternop_ = RELAXED_MADD), then: |
| a. Return $fvternop_(lanetype X M, $frelaxed_madd_, v_1, v_2, v_3). |
| 4. Assert: Due to validation, (vternop_ = RELAXED_NMADD). |
| 5. Return $fvternop_(lanetype X M, $frelaxed_nmadd_, v_1, v_2, v_3). |
| |
| vrelop_ lanetype X M vrelop_ v_1 v_2 |
| 1. If lanetype is Jnn, then: |
| a. If (vrelop_ = EQ), then: |
| 1) Return $ivrelop_(lanetype X M, $ieq_, v_1, v_2). |
| b. If (vrelop_ = NE), then: |
| 1) Return $ivrelop_(lanetype X M, $ine_, v_1, v_2). |
| c. If vrelop_ is some LT, then: |
| 1) Let (LT sx) be vrelop_. |
| 2) Return $ivrelopsx_(lanetype X M, $ilt_, sx, v_1, v_2). |
| d. If vrelop_ is some GT, then: |
| 1) Let (GT sx) be vrelop_. |
| 2) Return $ivrelopsx_(lanetype X M, $igt_, sx, v_1, v_2). |
| e. If vrelop_ is some LE, then: |
| 1) Let (LE sx) be vrelop_. |
| 2) Return $ivrelopsx_(lanetype X M, $ile_, sx, v_1, v_2). |
| f. If vrelop_ is some GE, then: |
| 1) Let (GE sx) be vrelop_. |
| 2) Return $ivrelopsx_(lanetype X M, $ige_, sx, v_1, v_2). |
| 2. Assert: Due to validation, lanetype is Fnn. |
| 3. If (vrelop_ = EQ), then: |
| a. Return $fvrelop_(lanetype X M, $feq_, v_1, v_2). |
| 4. If (vrelop_ = NE), then: |
| a. Return $fvrelop_(lanetype X M, $fne_, v_1, v_2). |
| 5. If (vrelop_ = LT), then: |
| a. Return $fvrelop_(lanetype X M, $flt_, v_1, v_2). |
| 6. If (vrelop_ = GT), then: |
| a. Return $fvrelop_(lanetype X M, $fgt_, v_1, v_2). |
| 7. If (vrelop_ = LE), then: |
| a. Return $fvrelop_(lanetype X M, $fle_, v_1, v_2). |
| 8. Assert: Due to validation, (vrelop_ = GE). |
| 9. Return $fvrelop_(lanetype X M, $fge_, v_1, v_2). |
| |
| lcvtop__ lanetype' X M_1 lanetype X M_2 vcvtop__ c_1 |
| 1. If lanetype' is Jnn, then: |
| a. If (lanetype is Jnn /\ vcvtop__ is some EXTEND), then: |
| 1) Let (EXTEND half sx) be vcvtop__. |
| 2) Let c be $extend__($lsizenn1(lanetype'), $lsizenn2(lanetype), sx, c_1). |
| 3) Return [c]. |
| b. If (lanetype is Fnn /\ vcvtop__ is some CONVERT), then: |
| 1) Let (CONVERT half? sx) be vcvtop__. |
| 2) Let c be $convert__($lsizenn1(lanetype'), $lsizenn2(lanetype), sx, c_1). |
| 3) Return [c]. |
| 2. Assert: Due to validation, lanetype' is Fnn. |
| 3. If lanetype is Inn, then: |
| a. If vcvtop__ is some TRUNC_SAT, then: |
| 1) Let (TRUNC_SAT sx zero?) be vcvtop__. |
| 2) Let c? be $trunc_sat__($lsizenn1(lanetype'), $lsizenn2(lanetype), sx, c_1). |
| 3) Return c?. |
| b. If vcvtop__ is some RELAXED_TRUNC, then: |
| 1) Let (RELAXED_TRUNC sx zero?) be vcvtop__. |
| 2) Let c? be $relaxed_trunc__($lsizenn1(lanetype'), $lsizenn2(lanetype), sx, c_1). |
| 3) Return c?. |
| 4. Assert: Due to validation, lanetype is Fnn. |
| 5. If (vcvtop__ = (DEMOTE ZERO)), then: |
| a. Let c* be $demote__($lsizenn1(lanetype'), $lsizenn2(lanetype), c_1). |
| b. Return c*. |
| 6. Assert: Due to validation, (vcvtop__ = PROMOTELOW). |
| 7. Let c* be $promote__($lsizenn1(lanetype'), $lsizenn2(lanetype), c_1). |
| 8. Return c*. |
| |
| vcvtop__ Lnn_1 X M Lnn_2 X M' vcvtop v_1 |
| 1. If ((M = M') /\ ($halfop(Lnn_1 X M', Lnn_2 X M', vcvtop) is not defined /\ $zeroop(Lnn_1 X M', Lnn_2 X M', vcvtop) is not defined)), then: |
| a. Let c_1* be $lanes_(Lnn_1 X M', v_1). |
| b. Let c** be $setproduct_(`lane_(Lnn_2), $lcvtop__(Lnn_1 X M', Lnn_2 X M', vcvtop, c_1)*). |
| c. Let v be an element of $inv_lanes_(Lnn_2 X M', c*)*. |
| d. Return v. |
| 2. If $halfop(Lnn_1 X M, Lnn_2 X M', vcvtop) is defined, then: |
| a. Let ?(half) be $halfop(Lnn_1 X M, Lnn_2 X M', vcvtop). |
| b. Let c_1* be $lanes_(Lnn_1 X M, v_1)[$half(half, 0, M') : M']. |
| c. Let c** be $setproduct_(`lane_(Lnn_2), $lcvtop__(Lnn_1 X M, Lnn_2 X M', vcvtop, c_1)*). |
| d. Let v be an element of $inv_lanes_(Lnn_2 X M', c*)*. |
| e. Return v. |
| 3. Assert: Due to validation, ($zeroop(Lnn_1 X M, Lnn_2 X M', vcvtop) = ?(ZERO)). |
| 4. Let c_1* be $lanes_(Lnn_1 X M, v_1). |
| 5. Let c** be $setproduct_(`lane_(Lnn_2), $lcvtop__(Lnn_1 X M, Lnn_2 X M', vcvtop, c_1)* :: [$zero(Lnn_2)]^M). |
| 6. Let v be an element of $inv_lanes_(Lnn_2 X M', c*)*. |
| 7. Return v. |
| |
| vshiftop_ Jnn X M vshiftop_ v i |
| 1. If (vshiftop_ = SHL), then: |
| a. Return $ivshiftop_(Jnn X M, $ishl_, v, i). |
| 2. Assert: Due to validation, vshiftop_ is some SHR. |
| 3. Let (SHR sx) be vshiftop_. |
| 4. Return $ivshiftopsx_(Jnn X M, $ishr_, sx, v, i). |
| |
| vbitmaskop_ Jnn X M v |
| 1. Return $ivbitmaskop_(Jnn X M, v). |
| |
| vswizzlop_ I8 X M vswizzlop_ v_1 v_2 |
| 1. If (vswizzlop_ = SWIZZLE), then: |
| a. Return $ivswizzlop_(I8 X M, $iswizzle_lane_, v_1, v_2). |
| 2. Assert: Due to validation, (vswizzlop_ = RELAXED_SWIZZLE). |
| 3. Return $ivswizzlop_(I8 X M, $irelaxed_swizzle_lane_, v_1, v_2). |
| |
| vshufflop_ I8 X M i* v_1 v_2 |
| 1. Return $ivshufflop_(I8 X M, i*, v_1, v_2). |
| |
| vnarrowop__ Jnn_1 X M_1 Jnn_2 X M_2 sx v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn_1 X M_1, v_1). |
| 2. Let c_2* be $lanes_(Jnn_1 X M_1, v_2). |
| 3. Let c'_1* be []. |
| 4. For each c_1 in c_1*, do: |
| a. Let c'_1 be $narrow__($lsize(Jnn_1), $lsize(Jnn_2), sx, c_1). |
| b. Append c'_1 to the c'_1*. |
| 5. Let c'_2* be []. |
| 6. For each c_2 in c_2*, do: |
| a. Let c'_2 be $narrow__($lsize(Jnn_1), $lsize(Jnn_2), sx, c_2). |
| b. Append c'_2 to the c'_2*. |
| 7. Let v be $inv_lanes_(Jnn_2 X M_2, c'_1* :: c'_2*). |
| 8. Return v. |
| |
| ivadd_pairwise_ N i* |
| 1. Let [j_1, j_2]* be $concat__1^-1(`N, i*). |
| 2. Return $iadd_(N, j_1, j_2)*. |
| |
| ivextunop__ Jnn_1 X M_1 Jnn_2 X M_2 $f_ sx v_1 |
| 1. Let c_1* be $lanes_(Jnn_1 X M_1, v_1). |
| 2. Let c'_1* be []. |
| 3. For each c_1 in c_1*, do: |
| a. Let c'_1 be $extend__($lsizenn1(Jnn_1), $lsizenn2(Jnn_2), sx, c_1). |
| b. Append c'_1 to the c'_1*. |
| 4. Let c* be $f_($lsizenn2(Jnn_2), c'_1*). |
| 5. Return $inv_lanes_(Jnn_2 X M_2, c*). |
| |
| vextunop__ Jnn_1 X M_1 Jnn_2 X M_2 (EXTADD_PAIRWISE sx) v_1 |
| 1. Return $ivextunop__(Jnn_1 X M_1, Jnn_2 X M_2, $ivadd_pairwise_, sx, v_1). |
| |
| ivdot_ N i_1* i_2* |
| 1. Let [j_1, j_2]* be $concat__1^-1(`iN(N), $imul_(N, i_1, i_2)*). |
| 2. Return $iadd_(N, j_1, j_2)*. |
| |
| ivdot_sat_ N i_1* i_2* |
| 1. Let [j_1, j_2]* be $concat__1^-1(`iN(N), $imul_(N, i_1, i_2)*). |
| 2. Return $iadd_sat_(N, S, j_1, j_2)*. |
| |
| ivextbinop__ Jnn_1 X M_1 Jnn_2 X M_2 $f_ sx_1 sx_2 i k v_1 v_2 |
| 1. Let c_1* be $lanes_(Jnn_1 X M_1, v_1)[i : k]. |
| 2. Let c_2* be $lanes_(Jnn_1 X M_1, v_2)[i : k]. |
| 3. Let c'_1* be []. |
| 4. For each c_1 in c_1*, do: |
| a. Let c'_1 be $extend__($lsizenn1(Jnn_1), $lsizenn2(Jnn_2), sx_1, c_1). |
| b. Append c'_1 to the c'_1*. |
| 5. Let c'_2* be []. |
| 6. For each c_2 in c_2*, do: |
| a. Let c'_2 be $extend__($lsizenn1(Jnn_1), $lsizenn2(Jnn_2), sx_2, c_2). |
| b. Append c'_2 to the c'_2*. |
| 7. Let c* be $f_($lsizenn2(Jnn_2), c'_1*, c'_2*). |
| 8. Return $inv_lanes_(Jnn_2 X M_2, c*). |
| |
| ivmul_ N i_1* i_2* |
| 1. Return $imul_(N, i_1, i_2)*. |
| |
| vextbinop__ Jnn_1 X M_1 Jnn_2 X M_2 vextbinop__ v_1 v_2 |
| 1. If vextbinop__ is some EXTMUL, then: |
| a. Let (EXTMUL half sx) be vextbinop__. |
| b. Return $ivextbinop__(Jnn_1 X M_1, Jnn_2 X M_2, $ivmul_, sx, sx, $half(half, 0, M_2), M_2, v_1, v_2). |
| 2. If (vextbinop__ = DOTS), then: |
| a. Return $ivextbinop__(Jnn_1 X M_1, Jnn_2 X M_2, $ivdot_, S, S, 0, M_1, v_1, v_2). |
| 3. Assert: Due to validation, (vextbinop__ = RELAXED_DOTS). |
| 4. Return $ivextbinop__(Jnn_1 X M_1, Jnn_2 X M_2, $ivdot_sat_, S, $relaxed2($R_idot(), `sx, S, U), 0, M_1, v_1, v_2). |
| |
| vextternop__ Jnn_1 X M_1 Jnn_2 X M_2 RELAXED_DOT_ADDS c_1 c_2 c_3 |
| 1. Let M be (2 * M_2). |
| 2. Let Jnn be $jsizenn^-1((2 * $lsizenn1(Jnn_1))). |
| 3. Let c' be $vextbinop__(Jnn_1 X M_1, Jnn X M, RELAXED_DOTS, c_1, c_2). |
| 4. Let c'' be $vextunop__(Jnn X M, Jnn_2 X M_2, (EXTADD_PAIRWISE S), c'). |
| 5. Let c be an element of $vbinop_(Jnn_2 X M_2, ADD, c'', c_3). |
| 6. Return c. |
| |
| Ki |
| 1. Return 1024. |
| |
| packfield_ storagetype val |
| 1. If storagetype is valtype, then: |
| a. Return val. |
| 2. Assert: Due to validation, storagetype is packtype. |
| 3. Assert: Due to validation, val is some CONST. |
| 4. Let (numtype_0.CONST i) be val. |
| 5. Assert: Due to validation, (numtype_0 = I32). |
| 6. Return (PACK storagetype $wrap__(32, $psize(storagetype), i)). |
| |
| unpackfield_ storagetype sx'? fieldval |
| 1. If (storagetype is valtype /\ (fieldval is val /\ sx'? is not defined)), then: |
| a. Return fieldval. |
| 2. Assert: Due to validation, fieldval is some PACK. |
| 3. Let (PACK packtype i) be fieldval. |
| 4. Assert: Due to validation, sx'? is defined. |
| 5. Let ?(sx) be sx'?. |
| 6. Assert: Due to validation, (storagetype = packtype). |
| 7. Return (I32.CONST $extend__($psize(packtype), 32, sx, i)). |
| |
| tagsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xa* be externaddr'*. |
| 3. If externaddr_0 is some TAG, then: |
| a. Let (TAG a) be externaddr_0. |
| b. Return [a] :: $tagsxa(xa*). |
| 4. Let [externaddr] :: xa* be externaddr'*. |
| 5. Return $tagsxa(xa*). |
| |
| globalsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xa* be externaddr'*. |
| 3. If externaddr_0 is some GLOBAL, then: |
| a. Let (GLOBAL a) be externaddr_0. |
| b. Return [a] :: $globalsxa(xa*). |
| 4. Let [externaddr] :: xa* be externaddr'*. |
| 5. Return $globalsxa(xa*). |
| |
| memsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xa* be externaddr'*. |
| 3. If externaddr_0 is some MEM, then: |
| a. Let (MEM a) be externaddr_0. |
| b. Return [a] :: $memsxa(xa*). |
| 4. Let [externaddr] :: xa* be externaddr'*. |
| 5. Return $memsxa(xa*). |
| |
| tablesxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xa* be externaddr'*. |
| 3. If externaddr_0 is some TABLE, then: |
| a. Let (TABLE a) be externaddr_0. |
| b. Return [a] :: $tablesxa(xa*). |
| 4. Let [externaddr] :: xa* be externaddr'*. |
| 5. Return $tablesxa(xa*). |
| |
| funcsxa externaddr'* |
| 1. If (externaddr'* = []), then: |
| a. Return []. |
| 2. Let [externaddr_0] :: xa* be externaddr'*. |
| 3. If externaddr_0 is some FUNC, then: |
| a. Let (FUNC a) be externaddr_0. |
| b. Return [a] :: $funcsxa(xa*). |
| 4. Let [externaddr] :: xa* be externaddr'*. |
| 5. Return $funcsxa(xa*). |
| |
| store (s, f) |
| 1. Return. |
| |
| frame (s, f) |
| 1. Return f. |
| |
| tagaddr (s, f) |
| 1. Return f.MODULE.TAGS. |
| |
| moduleinst (s, f) |
| 1. Return f.MODULE. |
| |
| taginst (s, f) |
| 1. Return s.TAGS. |
| |
| globalinst (s, f) |
| 1. Return s.GLOBALS. |
| |
| meminst (s, f) |
| 1. Return s.MEMS. |
| |
| tableinst (s, f) |
| 1. Return s.TABLES. |
| |
| funcinst (s, f) |
| 1. Return s.FUNCS. |
| |
| datainst (s, f) |
| 1. Return s.DATAS. |
| |
| eleminst (s, f) |
| 1. Return s.ELEMS. |
| |
| structinst (s, f) |
| 1. Return s.STRUCTS. |
| |
| arrayinst (s, f) |
| 1. Return s.ARRAYS. |
| |
| exninst (s, f) |
| 1. Return s.EXNS. |
| |
| fof z |
| 1. Return $frame(z). |
| |
| type z x |
| 1. Return $fof(z).MODULE.TYPES[x]. |
| |
| sof z |
| 1. Return $store(z). |
| |
| tag z x |
| 1. Return $sof(z).TAGS[$fof(z).MODULE.TAGS[x]]. |
| |
| global z x |
| 1. Return $sof(z).GLOBALS[$fof(z).MODULE.GLOBALS[x]]. |
| |
| mem z x |
| 1. Return $sof(z).MEMS[$fof(z).MODULE.MEMS[x]]. |
| |
| table z x |
| 1. Return $sof(z).TABLES[$fof(z).MODULE.TABLES[x]]. |
| |
| func z x |
| 1. Return $sof(z).FUNCS[$fof(z).MODULE.FUNCS[x]]. |
| |
| data z x |
| 1. Return $sof(z).DATAS[$fof(z).MODULE.DATAS[x]]. |
| |
| elem z x |
| 1. Return $sof(z).ELEMS[$fof(z).MODULE.ELEMS[x]]. |
| |
| local z x |
| 1. Return $fof(z).LOCALS[x]. |
| |
| with_local z x v |
| 1. Replace $fof(z).LOCALS[x] with ?(v). |
| |
| with_global z x v |
| 1. Replace $sof(z).GLOBALS[$fof(z).MODULE.GLOBALS[x]].VALUE with v. |
| |
| with_table z x i r |
| 1. Replace $sof(z).TABLES[$fof(z).MODULE.TABLES[x]].REFS[i] with r. |
| |
| with_tableinst z x ti |
| 1. Replace $sof(z).TABLES[$fof(z).MODULE.TABLES[x]] with ti. |
| |
| with_mem z x i j b* |
| 1. Replace $sof(z).MEMS[$fof(z).MODULE.MEMS[x]].BYTES[i : j] with b*. |
| |
| with_meminst z x mi |
| 1. Replace $sof(z).MEMS[$fof(z).MODULE.MEMS[x]] with mi. |
| |
| with_elem z x r* |
| 1. Replace $sof(z).ELEMS[$fof(z).MODULE.ELEMS[x]].REFS with r*. |
| |
| with_data z x b* |
| 1. Replace $sof(z).DATAS[$fof(z).MODULE.DATAS[x]].BYTES with b*. |
| |
| with_struct z a i fv |
| 1. Replace $sof(z).STRUCTS[a].FIELDS[i] with fv. |
| |
| with_array z a i fv |
| 1. Replace $sof(z).ARRAYS[a].FIELDS[i] with fv. |
| |
| add_structinst z si* |
| 1. Append si* to the $sof(z).STRUCTS. |
| |
| add_arrayinst z ai* |
| 1. Append ai* to the $sof(z).ARRAYS. |
| |
| add_exninst z exn* |
| 1. Append exn* to the $sof(z).EXNS. |
| |
| growtable tableinst n r |
| 1. Let { TYPE: (at ([ i .. j? ]) rt); REFS: r'* } be tableinst. |
| 2. Let i' be (|r'*| + n). |
| 3. If not (i' <= j)?, then: |
| a. Fail. |
| 4. If (i' <= ((2 ^ $size(at)) - 1)), then: |
| a. Let tableinst' be { TYPE: (at ([ i' .. j? ]) rt); REFS: r'* :: r^n }. |
| b. Return tableinst'. |
| 5. Fail. |
| |
| growmem meminst n |
| 1. Let { TYPE: at ([ i .. j? ]) PAGE; BYTES: b* } be meminst. |
| 2. Let i' be ((|b*| / (64 * $Ki())) + n). |
| 3. If not (i' <= j)?, then: |
| a. Fail. |
| 4. If (i' <= (2 ^ ($size(at) - 16))), then: |
| a. Let meminst' be { TYPE: at ([ i' .. j? ]) PAGE; BYTES: b* :: 0^(n * (64 * $Ki())) }. |
| b. Return meminst'. |
| 5. Fail. |
| |
| inst_valtype moduleinst t |
| 1. Return $subst_all_valtype(t, moduleinst.TYPES). |
| |
| inst_reftype moduleinst rt |
| 1. Return $subst_all_reftype(rt, moduleinst.TYPES). |
| |
| inst_globaltype moduleinst gt |
| 1. Return $subst_all_globaltype(gt, moduleinst.TYPES). |
| |
| inst_memtype moduleinst mt |
| 1. Return $subst_all_memtype(mt, moduleinst.TYPES). |
| |
| inst_tabletype moduleinst tt |
| 1. Return $subst_all_tabletype(tt, moduleinst.TYPES). |
| |
| blocktype_ z blocktype |
| 1. If blocktype is some _IDX, then: |
| a. Let (_IDX x) be blocktype. |
| b. Assert: Due to validation, $Expand($type(z, x)) is some ->. |
| c. Let (FUNC t_1* -> t_2*) be $Expand($type(z, x)). |
| d. Return t_1* ->_ [] t_2*. |
| 2. Assert: Due to validation, blocktype is some _RESULT. |
| 3. Let (_RESULT t?) be blocktype. |
| 4. Return [] ->_ [] t?. |
| |
| alloctypes type''* |
| 1. If (type''* = []), then: |
| a. Return []. |
| 2. Let type'* :: [type] be type''*. |
| 3. Let (TYPE rectype) be type. |
| 4. Let deftype'* be $alloctypes(type'*). |
| 5. Let x be |deftype'*|. |
| 6. Let deftype* be $subst_all_deftypes($rolldt(x, rectype), deftype'*). |
| 7. Return deftype'* :: deftype*. |
| |
| alloctag s tagtype |
| 1. Let taginst be { TYPE: tagtype }. |
| 2. Let a be |s.TAGS|. |
| 3. Append taginst to the s.TAGS. |
| 4. Return a. |
| |
| alloctags s tagtype''* |
| 1. If (tagtype''* = []), then: |
| a. Return []. |
| 2. Let [tagtype] :: tagtype'* be tagtype''*. |
| 3. Let ja be $alloctag(s, tagtype). |
| 4. Let ja'* be $alloctags(s, tagtype'*). |
| 5. Return [ja] :: ja'*. |
| |
| allocglobal s globaltype val |
| 1. Let globalinst be { TYPE: globaltype; VALUE: val }. |
| 2. Let a be |s.GLOBALS|. |
| 3. Append globalinst to the s.GLOBALS. |
| 4. Return a. |
| |
| allocglobals s globaltype''* val''* |
| 1. If (globaltype''* = []), then: |
| a. Assert: Due to validation, (val''* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [globaltype] :: globaltype'* be globaltype''*. |
| b. Assert: Due to validation, (|val''*| >= 1). |
| c. Let [val] :: val'* be val''*. |
| d. Let ga be $allocglobal(s, globaltype, val). |
| e. Let ga'* be $allocglobals(s, globaltype'*, val'*). |
| f. Return [ga] :: ga'*. |
| |
| allocmem s at ([ i .. j? ]) PAGE |
| 1. Let meminst be { TYPE: at ([ i .. j? ]) PAGE; BYTES: 0^(i * (64 * $Ki())) }. |
| 2. Let a be |s.MEMS|. |
| 3. Append meminst to the s.MEMS. |
| 4. Return a. |
| |
| allocmems s memtype''* |
| 1. If (memtype''* = []), then: |
| a. Return []. |
| 2. Let [memtype] :: memtype'* be memtype''*. |
| 3. Let ma be $allocmem(s, memtype). |
| 4. Let ma'* be $allocmems(s, memtype'*). |
| 5. Return [ma] :: ma'*. |
| |
| alloctable s (at ([ i .. j? ]) rt) ref |
| 1. Let tableinst be { TYPE: (at ([ i .. j? ]) rt); REFS: ref^i }. |
| 2. Let a be |s.TABLES|. |
| 3. Append tableinst to the s.TABLES. |
| 4. Return a. |
| |
| alloctables s tabletype''* ref''* |
| 1. If (ref''* = []), then: |
| a. Assert: Due to validation, (tabletype''* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [ref] :: ref'* be ref''*. |
| b. Assert: Due to validation, (|tabletype''*| >= 1). |
| c. Let [tabletype] :: tabletype'* be tabletype''*. |
| d. Let ta be $alloctable(s, tabletype, ref). |
| e. Let ta'* be $alloctables(s, tabletype'*, ref'*). |
| f. Return [ta] :: ta'*. |
| |
| allocfunc s deftype funccode moduleinst |
| 1. Let funcinst be { TYPE: deftype; MODULE: moduleinst; CODE: funccode }. |
| 2. Let a be |s.FUNCS|. |
| 3. Append funcinst to the s.FUNCS. |
| 4. Return a. |
| |
| allocfuncs s deftype* funccode''* moduleinst''* |
| 1. If (deftype* = []), then: |
| a. Assert: Due to validation, (funccode''* = []). |
| b. Assert: Due to validation, (moduleinst''* = []). |
| c. Return []. |
| 2. Else: |
| a. Let [dt] :: dt'* be deftype*. |
| b. Assert: Due to validation, (|funccode''*| >= 1). |
| c. Let [funccode] :: funccode'* be funccode''*. |
| d. Assert: Due to validation, (|moduleinst''*| >= 1). |
| e. Let [moduleinst] :: moduleinst'* be moduleinst''*. |
| f. Let fa be $allocfunc(s, dt, funccode, moduleinst). |
| g. Let fa'* be $allocfuncs(s, dt'*, funccode'*, moduleinst'*). |
| h. Return [fa] :: fa'*. |
| |
| allocdata s OK byte* |
| 1. Let datainst be { BYTES: byte* }. |
| 2. Let a be |s.DATAS|. |
| 3. Append datainst to the s.DATAS. |
| 4. Return a. |
| |
| allocdatas s datatype* byte* |
| 1. If (byte* = []), then: |
| a. Assert: Due to validation, (datatype* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [b*] :: b'** be byte*. |
| b. Assert: Due to validation, (|datatype*| >= 1). |
| c. Let [ok] :: ok'* be datatype*. |
| d. Let da be $allocdata(s, ok, b*). |
| e. Let da'* be $allocdatas(s, ok'*, b'**). |
| f. Return [da] :: da'*. |
| |
| allocelem s elemtype ref* |
| 1. Let eleminst be { TYPE: elemtype; REFS: ref* }. |
| 2. Let a be |s.ELEMS|. |
| 3. Append eleminst to the s.ELEMS. |
| 4. Return a. |
| |
| allocelems s elemtype* ref''* |
| 1. If (ref''* = []), then: |
| a. Assert: Due to validation, (elemtype* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [ref*] :: ref'** be ref''*. |
| b. Assert: Due to validation, (|elemtype*| >= 1). |
| c. Let [rt] :: rt'* be elemtype*. |
| d. Let ea be $allocelem(s, rt, ref*). |
| e. Let ea'* be $allocelems(s, rt'*, ref'**). |
| f. Return [ea] :: ea'*. |
| |
| allocexport moduleinst (EXPORT name externidx) |
| 1. If externidx is some TAG, then: |
| a. Let (TAG x) be externidx. |
| b. Return { NAME: name; ADDR: (TAG moduleinst.TAGS[x]) }. |
| 2. If externidx is some GLOBAL, then: |
| a. Let (GLOBAL x) be externidx. |
| b. Return { NAME: name; ADDR: (GLOBAL moduleinst.GLOBALS[x]) }. |
| 3. If externidx is some MEM, then: |
| a. Let (MEM x) be externidx. |
| b. Return { NAME: name; ADDR: (MEM moduleinst.MEMS[x]) }. |
| 4. If externidx is some TABLE, then: |
| a. Let (TABLE x) be externidx. |
| b. Return { NAME: name; ADDR: (TABLE moduleinst.TABLES[x]) }. |
| 5. Assert: Due to validation, externidx is some FUNC. |
| 6. Let (FUNC x) be externidx. |
| 7. Return { NAME: name; ADDR: (FUNC moduleinst.FUNCS[x]) }. |
| |
| allocexports moduleinst export* |
| 1. Return $allocexport(moduleinst, export)*. |
| |
| allocmodule s module externaddr* val_G* ref_T* ref_E** |
| 1. Let (MODULE type* import* tag* global* mem* table* func* data* elem* start? export*) be module. |
| 2. Let aa_I* be $tagsxa(externaddr*). |
| 3. Let ga_I* be $globalsxa(externaddr*). |
| 4. Let fa_I* be $funcsxa(externaddr*). |
| 5. Let ma_I* be $memsxa(externaddr*). |
| 6. Let ta_I* be $tablesxa(externaddr*). |
| 7. Let fa* be (|s.FUNCS| + i_F)^(i_F<|func*|). |
| 8. Let tagtype* be []. |
| 9. For each tag in tag*, do: |
| a. Let (TAG tagtype) be tag. |
| b. Append tagtype to the tagtype*. |
| 10. Let byte** be []. |
| 11. For each data in data*, do: |
| a. Let (DATA byte* datamode) be data. |
| b. Append byte* to the byte**. |
| 12. Let globaltype* be []. |
| 13. For each global in global*, do: |
| a. Let (GLOBAL globaltype expr_G) be global. |
| b. Append globaltype to the globaltype*. |
| 14. Let tabletype* be []. |
| 15. For each table in table*, do: |
| a. Let (TABLE tabletype expr_T) be table. |
| b. Append tabletype to the tabletype*. |
| 16. Let memtype* be []. |
| 17. For each mem in mem*, do: |
| a. Let (MEMORY memtype) be mem. |
| b. Append memtype to the memtype*. |
| 18. Let dt* be $alloctypes(type*). |
| 19. Let elemtype* be []. |
| 20. For each elem in elem*, do: |
| a. Let (ELEM elemtype expr_E* elemmode) be elem. |
| b. Append elemtype to the elemtype*. |
| 21. Let expr_F* be []. |
| 22. Let local** be []. |
| 23. Let x* be []. |
| 24. For each func in func*, do: |
| a. Let (FUNC x local* expr_F) be func. |
| b. Append expr_F to the expr_F*. |
| c. Append local* to the local**. |
| d. Append x to the x*. |
| 25. Let aa* be []. |
| 26. For each tagtype in tagtype*, do: |
| a. Let aa be $alloctag(s, $subst_all_tagtype(tagtype, dt*)). |
| b. Append aa to the aa*. |
| 27. Let ga* be []. |
| 28. For each globaltype in globaltype* and val_G in val_G*, do: |
| a. Let ga be $allocglobal(s, $subst_all_globaltype(globaltype, dt*), val_G). |
| b. Append ga to the ga*. |
| 29. Let ma* be []. |
| 30. For each memtype in memtype*, do: |
| a. Let ma be $allocmem(s, $subst_all_memtype(memtype, dt*)). |
| b. Append ma to the ma*. |
| 31. Let ta* be []. |
| 32. For each tabletype in tabletype* and ref_T in ref_T*, do: |
| a. Let ta be $alloctable(s, $subst_all_tabletype(tabletype, dt*), ref_T). |
| b. Append ta to the ta*. |
| 33. Let xi* be []. |
| 34. For each export in export*, do: |
| a. Let xi be $allocexport({ TAGS: aa_I* :: aa*; GLOBALS: ga_I* :: ga*; MEMS: ma_I* :: ma*; TABLES: ta_I* :: ta*; FUNCS: fa_I* :: fa* }, export). |
| b. Append xi to the xi*. |
| 35. Let da* be []. |
| 36. For each byte* in byte**, do: |
| a. Let da be $allocdata(s, OK, byte*). |
| b. Append da to the da*. |
| 37. Let ea* be []. |
| 38. For each elemtype in elemtype* and ref_E* in ref_E**, do: |
| a. Let ea be $allocelem(s, $subst_all_reftype(elemtype, dt*), ref_E*). |
| b. Append ea to the ea*. |
| 39. Let moduleinst be { TYPES: dt*; TAGS: aa_I* :: aa*; GLOBALS: ga_I* :: ga*; MEMS: ma_I* :: ma*; TABLES: ta_I* :: ta*; FUNCS: fa_I* :: fa*; DATAS: da*; ELEMS: ea*; EXPORTS: xi* }. |
| 40. Let funcaddr_0* be []. |
| 41. For each expr_F in expr_F* and local* in local** and x in x*, do: |
| a. Let funcaddr_0 be $allocfunc(s, dt*[x], (FUNC x local* expr_F), moduleinst). |
| b. Append funcaddr_0 to the funcaddr_0*. |
| 42. Assert: Due to validation, (funcaddr_0* = fa*). |
| 43. Return moduleinst. |
| |
| rundata_ x (DATA b^n datamode) |
| 1. If (datamode = PASSIVE), then: |
| a. Return []. |
| 2. Assert: Due to validation, datamode is some ACTIVE. |
| 3. Let (ACTIVE y instr*) be datamode. |
| 4. Return instr* :: [(I32.CONST 0), (I32.CONST n), (MEMORY.INIT y x), (DATA.DROP x)]. |
| |
| runelem_ x (ELEM rt e^n elemmode) |
| 1. If (elemmode = PASSIVE), then: |
| a. Return []. |
| 2. If (elemmode = DECLARE), then: |
| a. Return [(ELEM.DROP x)]. |
| 3. Assert: Due to validation, elemmode is some ACTIVE. |
| 4. Let (ACTIVE y instr*) be elemmode. |
| 5. Return instr* :: [(I32.CONST 0), (I32.CONST n), (TABLE.INIT y x), (ELEM.DROP x)]. |
| |
| evalexprs z expr''* |
| 1. If (expr''* = []), then: |
| a. Return []. |
| 2. Let [expr] :: expr'* be expr''*. |
| 3. Let [ref] be $Eval_expr(z, expr). |
| 4. Let ref'* be $evalexprs(z, expr'*). |
| 5. Return [ref] :: ref'*. |
| |
| evalexprss z expr''* |
| 1. If (expr''* = []), then: |
| a. Return []. |
| 2. Let [expr*] :: expr'** be expr''*. |
| 3. Let ref* be $evalexprs(z, expr*). |
| 4. Let ref'** be $evalexprss(z, expr'**). |
| 5. Return [ref*] :: ref'**. |
| |
| evalglobals z globaltype* expr''* |
| 1. If (expr''* = []), then: |
| a. Assert: Due to validation, (globaltype* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [expr] :: expr'* be expr''*. |
| b. Assert: Due to validation, (|globaltype*| >= 1). |
| c. Let [gt] :: gt'* be globaltype*. |
| d. Let [val] be $Eval_expr(z, expr). |
| e. Let (s, f) be z. |
| f. Let a be $allocglobal(s, gt, val). |
| g. Append a to the f.MODULE.GLOBALS. |
| h. Let val'* be $evalglobals((s, f), gt'*, expr'*). |
| i. Return [val] :: val'*. |
| |
| instantiate s module externaddr* |
| 1. Let xt_I* -> xt_E* be $Module_ok(module). |
| 2. Let (MODULE type* import* tag* global* mem* table* func* data* elem* start? export*) be module. |
| 3. If not $Externaddr_ok(externaddr, xt_I)*, then: |
| a. Fail. |
| 4. Let instr_D* be $concat_(`instr, $rundata_(i_D, data*[i_D])^(i_D<|data*|)). |
| 5. Let instr_E* be $concat_(`instr, $runelem_(i_E, elem*[i_E])^(i_E<|elem*|)). |
| 6. Let moduleinst_0 be { TYPES: $alloctypes(type*); GLOBALS: $globalsxa(externaddr*); FUNCS: $funcsxa(externaddr*) :: (|s.FUNCS| + i_F)^(i_F<|func*|) }. |
| 7. Let expr_T* be []. |
| 8. For each table in table*, do: |
| a. Let (TABLE tabletype expr_T) be table. |
| b. Append expr_T to the expr_T*. |
| 9. Let expr_G* be []. |
| 10. Let globaltype* be []. |
| 11. For each global in global*, do: |
| a. Let (GLOBAL globaltype expr_G) be global. |
| b. Append expr_G to the expr_G*. |
| c. Append globaltype to the globaltype*. |
| 12. Let expr_E** be []. |
| 13. For each elem in elem*, do: |
| a. Let (ELEM reftype expr_E* elemmode) be elem. |
| b. Append expr_E* to the expr_E**. |
| 14. Let z be (s, { MODULE: moduleinst_0 }). |
| 15. Push the frame (FRAME_ 0 { $frame(z) }) to the stack. |
| 16. Let val_G* be $evalglobals(z, globaltype*, expr_G*). |
| 17. Let ref_T* be $evalexprs(z, expr_T*). |
| 18. Let ref_E** be $evalexprss(z, expr_E**). |
| 19. Pop the frame (FRAME_ 0 { f }) from the stack. |
| 20. Let (s, f) be z. |
| 21. Let moduleinst be $allocmodule(s, module, externaddr*, val_G*, ref_T*, ref_E**). |
| 22. Push the frame (FRAME_ 0 { { MODULE: moduleinst } }) to the stack. |
| 23. Execute the sequence instr_E*. |
| 24. Execute the sequence instr_D*. |
| 25. If start? is defined, then: |
| a. Let ?((START x)) be start?. |
| b. Let instr_S be (CALL x). |
| c. Execute the instruction instr_S. |
| 26. Pop the frame (FRAME_ 0 { { MODULE: moduleinst } }) from the stack. |
| 27. Return moduleinst. |
| |
| invoke s funcaddr val* |
| 1. Assert: Due to validation, $Expand(s.FUNCS[funcaddr].TYPE) is some ->. |
| 2. Let (FUNC t_1* -> t_2*) be $Expand(s.FUNCS[funcaddr].TYPE). |
| 3. If not $Val_ok(val, t_1)*, then: |
| a. Fail. |
| 4. Let k be |t_2*|. |
| 5. Push the frame (FRAME_ k { { MODULE: {} } }) to the stack. |
| 6. Push the values val* to the stack. |
| 7. Push the value (REF.FUNC_ADDR funcaddr) to the stack. |
| 8. Execute the instruction (CALL_REF s.FUNCS[funcaddr].TYPE). |
| 9. Pop the values val'^k from the stack. |
| 10. Pop the frame (FRAME_ k { { MODULE: {} } }) from the stack. |
| 11. Return val'^k. |
| |
| concat_idctxt idctxt* |
| 1. If (idctxt* = []), then: |
| a. Return {}. |
| 2. Let [I] :: I'* be idctxt*. |
| 3. Return I ++ $concat_idctxt(I'*). |
| |
| typesd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [type] :: decl'* be decl'*. |
| 3. Return [type] :: $typesd(decl'*). |
| |
| importsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [import] :: decl'* be decl'*. |
| 3. Return [import] :: $importsd(decl'*). |
| |
| tagsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [tag] :: decl'* be decl'*. |
| 3. Return [tag] :: $tagsd(decl'*). |
| |
| globalsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [global] :: decl'* be decl'*. |
| 3. Return [global] :: $globalsd(decl'*). |
| |
| memsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [mem] :: decl'* be decl'*. |
| 3. Return [mem] :: $memsd(decl'*). |
| |
| tablesd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [table] :: decl'* be decl'*. |
| 3. Return [table] :: $tablesd(decl'*). |
| |
| funcsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [func] :: decl'* be decl'*. |
| 3. Return [func] :: $funcsd(decl'*). |
| |
| datasd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [data] :: decl'* be decl'*. |
| 3. Return [data] :: $datasd(decl'*). |
| |
| elemsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [elem] :: decl'* be decl'*. |
| 3. Return [elem] :: $elemsd(decl'*). |
| |
| startsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [start] :: decl'* be decl'*. |
| 3. Return [start] :: $startsd(decl'*). |
| |
| exportsd decl'* |
| 1. If (decl'* = []), then: |
| a. Return []. |
| 2. Let [export] :: decl'* be decl'*. |
| 3. Return [export] :: $exportsd(decl'*). |
| |
| ordered decl* |
| 1. If ($importsd(decl*) = []), then: |
| a. Return true. |
| 2. Assert: Due to validation, YetE (Nondeterministic assignment target: decl_1*{decl_1 <- decl_1*} :: [import] :: decl_2*{decl_2 <- decl_2*}). |
| 3. Let decl_1* :: [import] :: decl_2* be decl*. |
| 4. Return (((((($importsd(decl_1*) = []) /\ ($tagsd(decl_1*) = [])) /\ ($globalsd(decl_1*) = [])) /\ ($memsd(decl_1*) = [])) /\ ($tablesd(decl_1*) = [])) /\ ($funcsd(decl_1*) = [])). |
| |
| NotImmutReachable fv_1 s fv_2 |
| 1. If the relation ImmutReachable(fv_1, s, fv_2) holds, then: |
| a. Return false. |
| 2. Return true. |
| |
| allocXs `X `Y s X''* Y''* |
| 1. If (X''* = []), then: |
| a. Assert: Due to validation, (Y''* = []). |
| b. Return []. |
| 2. Else: |
| a. Let [X] :: X'* be X''*. |
| b. Assert: Due to validation, (|Y''*| >= 1). |
| c. Let [Y] :: Y'* be Y''*. |
| d. Let a be $allocX(`X, `Y, s, X, Y). |
| e. Let a'* be $allocXs(`X, `Y, s, X'*, Y'*). |
| f. Return [a] :: a'*. |
| |
| var `X |
| 1. Return 0. |
| |
| Eval_expr instr* |
| 1. Execute the sequence instr*. |
| 2. Pop the value val from the stack. |
| 3. Return [val]. |
| |
| == Complete. |
| ``` |
