Skip to content
This repository was archived by the owner on Nov 3, 2021. It is now read-only.

Fix various TODOs #72

Merged
merged 4 commits into from
Jan 16, 2020
Merged

Fix various TODOs #72

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
ed92058
[interpreter] Move to small-step semantics
rossberg Jan 13, 2020
dfb4c6c
Todos
rossberg Jan 13, 2020
bb2aa93
Fix numbering
rossberg Jan 14, 2020
29f785e
Renaming meta var
rossberg Jan 14, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 1 addition & 3 deletions document/core/appendix/properties.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -286,8 +286,6 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
.. index:: element instance, reference
.. _valid-eleminst:

.. todo:: TODO: adjust elem instances

:ref:`Element Instances <syntax-eleminst>` :math:`\{ \EIELEM~\X{fa}^\ast \}`
............................................................................

Expand All @@ -303,7 +301,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
\frac{
(S \vdash \reff : t')^\ast
\qquad
(\vdashreftypematch t' \matchesvaltype t)^n
(\vdashreftypematch t' \matchesvaltype t)^\ast
}{
S \vdasheleminst \{ \EITYPE~t, \EIELEM~\reff^\ast \} \ok
}
Expand Down
2 changes: 1 addition & 1 deletion document/core/exec/conventions.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,7 @@ The following conventions are adopted in stating these rules.

* The execution rules also assume the presence of an implicit :ref:`stack <stack>`
that is modified by *pushing* or *popping*
:ref:`values <syntax-value>`, :ref:`function elements <syntax-funcelem>`, :ref:`labels <syntax-label>`, and :ref:`frames <syntax-frame>`.
:ref:`values <syntax-value>`, :ref:`labels <syntax-label>`, and :ref:`frames <syntax-frame>`.

* Certain rules require the stack to contain at least one frame.
The most recent frame is referred to as the *current* frame.
Expand Down
114 changes: 59 additions & 55 deletions document/core/exec/instructions.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -633,11 +633,11 @@ Table Instructions

2. Assert: due to :ref:`validation <valid-table.fill>`, :math:`F.\AMODULE.\MITABLES[x]` exists.

3. Let :math:`a` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[x]`.
3. Let :math:`\X{ta}` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[x]`.

4. Assert: due to :ref:`validation <valid-table.fill>`, :math:`S.\STABLES[a]` exists.
4. Assert: due to :ref:`validation <valid-table.fill>`, :math:`S.\STABLES[\X{ta}]` exists.

5. Let :math:`\X{tab}` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[a]`.
5. Let :math:`\X{tab}` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\X{ta}]`.

6. Assert: due to :ref:`validation <valid-table.fill>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.

Expand Down Expand Up @@ -693,50 +693,56 @@ Table Instructions

.. _exec-table.copy:

:math:`\TABLECOPY`
..................

.. todo:: TODO: multi tables
:math:`\TABLECOPY~x~y`
......................

1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.

2. Assert: due to :ref:`validation <valid-table.copy>`, :math:`F.\AMODULE.\MITABLES[0]` exists.
2. Assert: due to :ref:`validation <valid-table.copy>`, :math:`F.\AMODULE.\MITABLES[x]` exists.

3. Let :math:`\X{ta}` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[0]`.
3. Let :math:`\X{ta}_x` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[x]`.

4. Assert: due to :ref:`validation <valid-table.copy>`, :math:`S.\STABLES[\X{ta}]` exists.
4. Assert: due to :ref:`validation <valid-table.copy>`, :math:`S.\STABLES[\X{ta}_x]` exists.

5. Let :math:`\X{tab}` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\X{ta}]`.
5. Let :math:`\X{tab}_x` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\X{ta}_x]`.

6. Assert: due to :ref:`validation <valid-table.copy>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
6. Assert: due to :ref:`validation <valid-table.copy>`, :math:`F.\AMODULE.\MITABLES[y]` exists.

7. Pop the value :math:`\I32.\CONST~n` from the stack.
7. Let :math:`\X{ta}_y` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[y]`.

8. Assert: due to :ref:`validation <valid-table.copy>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
8. Assert: due to :ref:`validation <valid-table.copy>`, :math:`S.\STABLES[\X{ta}_y]` exists.

9. Pop the value :math:`\I32.\CONST~s` from the stack.
9. Let :math:`\X{tab}_y` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\X{ta}_y]`.

10. Assert: due to :ref:`validation <valid-table.copy>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.

11. Pop the value :math:`\I32.\CONST~d` from the stack.
11. Pop the value :math:`\I32.\CONST~n` from the stack.

12. Assert: due to :ref:`validation <valid-table.copy>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.

13. Pop the value :math:`\I32.\CONST~s` from the stack.

12. If :math:`s + n` is larger than the length of :math:`\X{tab}.\TIELEM` or :math:`d + n` is larger than the length of :math:`\X{tab}.\TIELEM`, then:
14. Assert: due to :ref:`validation <valid-table.copy>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.

15. Pop the value :math:`\I32.\CONST~d` from the stack.

16. If :math:`s + n` is larger than the length of :math:`\X{tab}_y.\TIELEM` or :math:`d + n` is larger than the length of :math:`\X{tab}_x.\TIELEM`, then:

a. Trap.

13. If :math:`n = 0`, then:
17. If :math:`n = 0`, then:

a. Return.

14. If :math:`d \leq s`, then:
18. If :math:`d \leq s`, then:

a. Push the value :math:`\I32.\CONST~d` to the stack.

b. Push the value :math:`\I32.\CONST~s` to the stack.

c. Execute the instruction :math:`\TABLEGET`.
c. Execute the instruction :math:`\TABLEGET~y`.

d. Execute the instruction :math:`\TABLESET`.
d. Execute the instruction :math:`\TABLESET~x`.

e. Assert: due to the earlier check against the table size, :math:`d+1 < 2^{32}`.

Expand All @@ -746,7 +752,7 @@ Table Instructions

h. Push the value :math:`\I32.\CONST~(s+1)` to the stack.

15. Else:
19. Else:

a. Assert: due to the earlier check against the table size, :math:`d+n-1 < 2^{32}`.

Expand All @@ -756,48 +762,48 @@ Table Instructions

d. Push the value :math:`\I32.\CONST~(s+n-1)` to the stack.

c. Execute the instruction :math:`\TABLEGET`.
c. Execute the instruction :math:`\TABLEGET~y`.

f. Execute the instruction :math:`\TABLESET`.
f. Execute the instruction :math:`\TABLESET~x`.

g. Push the value :math:`\I32.\CONST~d` to the stack.

h. Push the value :math:`\I32.\CONST~s` to the stack.

16. Push the value :math:`\I32.\CONST~(n-1)` to the stack.
20. Push the value :math:`\I32.\CONST~(n-1)` to the stack.

17. Execute the instruction :math:`\TABLECOPY`.
21. Execute the instruction :math:`\TABLECOPY~x~y`.

.. math::
~\\[-1ex]
\begin{array}{l}
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~\TABLECOPY
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~(\TABLECOPY~x~y)
\quad\stepto\quad S; F; \TRAP
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\iff & s + n > |S.\STABLES[F.\AMODULE.\MITABLES[0]].\TIELEM| \\
\vee & d + n > |S.\STABLES[F.\AMODULE.\MITABLES[0]].\TIELEM|) \\
(\iff & s + n > |S.\STABLES[F.\AMODULE.\MITABLES[y]].\TIELEM| \\
\vee & d + n > |S.\STABLES[F.\AMODULE.\MITABLES[x]].\TIELEM|) \\
\end{array}
\\[1ex]
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~0)~\TABLECOPY
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~0)~(\TABLECOPY~x~y)
\quad\stepto\quad S; F; \epsilon
\\ \qquad
(\otherwise)
\\[1ex]
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n+1)~\TABLECOPY
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n+1)~(\TABLECOPY~x~y)
\quad\stepto\quad S; F;
\begin{array}[t]{@{}l@{}}
(\I32.\CONST~d)~(\I32.\CONST~s)~\TABLEGET~\TABLESET \\
(\I32.\CONST~d+1)~(\I32.\CONST~s+1)~(\I32.\CONST~n)~\TABLECOPY \\
(\I32.\CONST~d)~(\I32.\CONST~s)~(\TABLEGET~y)~(\TABLESET~x) \\
(\I32.\CONST~d+1)~(\I32.\CONST~s+1)~(\I32.\CONST~n)~(\TABLECOPY~x~y) \\
\end{array}
\\ \qquad
(\otherwise, \iff d \leq s)
\\[1ex]
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n+1)~\TABLECOPY
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n+1)~(\TABLECOPY~x~y)
\quad\stepto\quad S; F;
\begin{array}[t]{@{}l@{}}
(\I32.\CONST~d+n-1)~(\I32.\CONST~s+n-1)~\TABLEGET~\TABLESET \\
(\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~\TABLECOPY \\
(\I32.\CONST~d+n-1)~(\I32.\CONST~s+n-1)~(\TABLEGET~y)~(\TABLESET~x) \\
(\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~(\TABLECOPY~x~y) \\
\end{array}
\\ \qquad
(\otherwise, \iff d > s) \\
Expand All @@ -806,24 +812,22 @@ Table Instructions

.. _exec-table.init:

:math:`\TABLEINIT~x`
....................

.. todo:: TODO: multi tables
:math:`\TABLEINIT~x~y`
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should we use s like segment here instead of y? Or could we even use seg?

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

These are in the syntactic class of indices, which are ranged over by x and y per the convention established in the respective section.

......................

1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.

2. Assert: due to :ref:`validation <valid-table.init>`, :math:`F.\AMODULE.\MITABLES[0]` exists.
2. Assert: due to :ref:`validation <valid-table.init>`, :math:`F.\AMODULE.\MITABLES[x]` exists.

3. Let :math:`\X{ta}` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[0]`.
3. Let :math:`\X{ta}` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[x]`.

4. Assert: due to :ref:`validation <valid-table.init>`, :math:`S.\STABLES[\X{ta}]` exists.

5. Let :math:`\X{tab}` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\X{ta}]`.

6. Assert: due to :ref:`validation <valid-table.init>`, :math:`F.\AMODULE.\MIELEMS[x]` exists.
6. Assert: due to :ref:`validation <valid-table.init>`, :math:`F.\AMODULE.\MIELEMS[y]` exists.

7. Let :math:`\X{ea}` be the :ref:`element address <syntax-elemaddr>` :math:`F.\AMODULE.\MIELEMS[x]`.
7. Let :math:`\X{ea}` be the :ref:`element address <syntax-elemaddr>` :math:`F.\AMODULE.\MIELEMS[y]`.

8. Assert: due to :ref:`validation <valid-table.init>`, :math:`S.\SELEMS[\X{ea}]` exists.

Expand All @@ -849,13 +853,13 @@ Table Instructions

a. Return.

18. Let :math:`\funcelem` be the :ref:`function element <syntax-funcelem>` :math:`\X{elem}.\EIELEM[s]`.
18. Let :math:`\val` be the :ref:`reference value <syntax-ref>` :math:`\X{elem}.\EIELEM[s]`.

19. Push the value :math:`\I32.\CONST~d` to the stack.

20. Push the value :math:`\funcelem` to the stack.
20. Push the value :math:`\val` to the stack.

21. Execute the instruction :math:`\TABLESET`.
21. Execute the instruction :math:`\TABLESET~x`.

22. Assert: due to the earlier check against the table size, :math:`d+1 < 2^{32}`.

Expand All @@ -867,32 +871,32 @@ Table Instructions

26. Push the value :math:`\I32.\CONST~(n-1)` to the stack.

27. Execute the instruction :math:`\TABLEINIT~x`.
27. Execute the instruction :math:`\TABLEINIT~x~y`.

.. math::
~\\[-1ex]
\begin{array}{l}
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~(\TABLEINIT~x)
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~(\TABLEINIT~x~y)
\quad\stepto\quad S; F; \TRAP
\\ \qquad
\begin{array}[t]{@{}r@{~}l@{}}
(\iff & s + n > |S.\SELEMS[F.\AMODULE.\MIELEMS[x]].\EIELEM| \\
(\iff & s + n > |S.\SELEMS[F.\AMODULE.\MIELEMS[y]].\EIELEM| \\
\vee & d + n > |S.\STABLES[F.\AMODULE.\MITABLES[x]].\TIELEM|) \\
\end{array}
\\[1ex]
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~0)~(\TABLEINIT~x)
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~0)~(\TABLEINIT~x~y)
\quad\stepto\quad S; F; \epsilon
\\ \qquad
(\otherwise)
\\[1ex]
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n+1)~(\TABLEINIT~x)
S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n+1)~(\TABLEINIT~x~y)
\quad\stepto\quad S; F;
\begin{array}[t]{@{}l@{}}
(\I32.\CONST~d)~\funcelem~(\TABLESET~x) \\
(\I32.\CONST~d+1)~(\I32.\CONST~s+1)~(\I32.\CONST~n)~(\TABLEINIT~x) \\
(\I32.\CONST~d)~\val~(\TABLESET~x) \\
(\I32.\CONST~d+1)~(\I32.\CONST~s+1)~(\I32.\CONST~n)~(\TABLEINIT~x~y) \\
\end{array}
\\ \qquad
(\otherwise, \iff \funcelem = S.\SELEMS[F.\AMODULE.\MIELEMS[x]].\EIELEM[s]) \\
(\otherwise, \iff \val = S.\SELEMS[F.\AMODULE.\MIELEMS[x]].\EIELEM[s]) \\
\end{array}


Expand Down
25 changes: 14 additions & 11 deletions document/core/exec/modules.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -630,21 +630,21 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep

6. Let :math:`(\reff^\ast)^\ast` be the list of :ref:`reference <syntax-ref>` vectors determined by the :ref:`element segments <syntax-elem>` in :math:`\module`. These may be calculated as follows.

.. todo:: TODO desugar funcelem
a. Let :math:`\moduleinst_{\F{im}}` be the auxiliary module :ref:`instance <syntax-moduleinst>` :math:`\{\MIGLOBALS~\evglobals(\externval^n)\}` that only consists of the imported globals.

a. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, and for each element :ref:`expression <syntax-expr>` :math:`\expr_{ij}` in :math:`\elem_i.\EINIT`, do:
b. Let :math:`F_{\F{im}}` be the auxiliary :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst_{\F{im}}, \ALOCALS~\epsilon \}`.

i. If :math:`\expr_{ij}` is of the form :math:`\REFNULL`, then let the :ref:`function element <syntax-funcelem>` :math:`\funcelem_{ij}` be :math:`\epsilon`.
c. Push the frame :math:`F_{\F{im}}` to the stack.

ii. Else, :math:`\expr_{ij}` is of the form is :math:`\REFFUNC~\funcidx_{ij}`.
d. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, and for each element :ref:`expression <syntax-expr>` :math:`\expr_{ij}` in :math:`\elem_i.\EINIT`, do:

iii. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\MIFUNCS[\funcidx_{ij}]` exists.
i. Let :math:`\reff_{ij}` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\expr_{ij}`.

iv. Let the :ref:`function element <syntax-funcelem>` :math:`\funcelem_{ij}` be the :ref:`function address <syntax-funcaddr>` :math:`\moduleinst.\MIFUNCS[\funcidx_{ij}]`.
e. Pop the frame :math:`F_{\F{im}}` from the stack.

b. Let :math:`\funcelem^\ast_i` be the concatenation of function elements :math:`\funcelem_{ij}` in order of index :math:`j`.
f. Let :math:`\reff^\ast_i` be the concatenation of function elements :math:`\reff_{ij}` in order of index :math:`j`.

c. Let :math:`(\funcelem^\ast)^\ast` be the concatenation of function element vectors :math:`\funcelem^\ast_i` in order of index :math:`i`.
g. Let :math:`(\reff^\ast)^\ast` be the concatenation of function element vectors :math:`\reff^\ast_i` in order of index :math:`i`.

7. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^n`, global initializer values :math:`\val^\ast`, and element segment contents :math:`(\reff^\ast)^\ast`, and let :math:`S'` be the extended store produced by module allocation.

Expand Down Expand Up @@ -711,10 +711,13 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
&\wedge& \module.\MGLOBALS = \global^\ast \\
&\wedge& \module.\MELEMS = \elem^n \\
&\wedge& \module.\MDATAS = \data^m \\
&\wedge& \module.\MSTART = \start^? \\[1ex]
&\wedge& S', \moduleinst = \allocmodule(S, \module, \externval^k, \val^\ast) \\
&\wedge& \module.\MSTART = \start^? \\
&\wedge& (\expr_{\F{g}} = \global.GINIT)^\ast \\
&\wedge& (\expr_{\F{e}}^\ast = \elem.EINIT)^n \\[1ex]
&\wedge& S', \moduleinst = \allocmodule(S, \module, \externval^k, \val^\ast, (\reff^\ast)^n) \\
&\wedge& F = \{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \} \\[1ex]
&\wedge& (S'; F; \global.\GINIT \stepto^\ast S'; F; \val~\END)^\ast \\
&\wedge& (S'; F; \expr_{\F{g}} \stepto^\ast S'; F; \val~\END)^\ast \\
&\wedge& ((S'; F; \expr_{\F{e}} \stepto^\ast S'; F; \reff~\END)^\ast)^n \\
&\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
&\wedge& (\memaddr = \moduleinst.\MIMEMS[\data.\DMEM])^\ast \\
&\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^?)
Expand Down
3 changes: 1 addition & 2 deletions document/core/exec/runtime.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -258,7 +258,6 @@ but within certain :ref:`constraints <exec-invoke-host>` that ensure the integri
.. index:: ! table instance, table, function address, table type, embedder, element segment
pair: abstract syntax; table instance
pair: table; instance
.. _syntax-funcelem:
.. _syntax-tableinst:

Table Instances
Expand Down Expand Up @@ -340,7 +339,7 @@ It holds a vector of references and their common :ref:`type <syntax-reftype>`.
.. math::
\begin{array}{llll}
\production{(element instance)} & \eleminst &::=&
\{ \EITYPE~\reftype, \EIELEM~\vec(\funcelem) \} \\
\{ \EITYPE~\reftype, \EIELEM~\vec(\reff) \} \\
\end{array}


Expand Down
22 changes: 20 additions & 2 deletions document/core/text/instructions.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -215,12 +215,30 @@ Table Instructions
\text{table.size}~~x{:}\Ttableidx_I &\Rightarrow& \TABLESIZE~x \\ &&|&
\text{table.grow}~~x{:}\Ttableidx_I &\Rightarrow& \TABLEGROW~x \\ &&|&
\text{table.fill}~~x{:}\Ttableidx_I &\Rightarrow& \TABLEFILL~x \\
\text{table.copy} &\Rightarrow& \TABLECOPY \\ &&|&
\text{table.init}~~x{:}\Telemidx_I &\Rightarrow& \TABLEINIT~x \\ &&|&
\text{table.copy}~~x{:}\Ttableidx_I~~y{:}\Ttableidx_I &\Rightarrow& \TABLECOPY~x~y \\ &&|&
\text{table.init}~~x{:}\Ttableidx_I~~y{:}\Telemidx_I &\Rightarrow& \TABLEINIT~x~y \\ &&|&
\text{elem.drop}~~x{:}\Telemidx_I &\Rightarrow& \ELEMDROP~x \\
\end{array}


Abbreviations
.............

For backwards compatibility, all :math:`table indices <syntax-tableidx>` may be omitted from table instructions, defaulting to :math:`0`.

.. math::
\begin{array}{llclll}
\production{instruction} &
\text{table.get} &\equiv& \text{table.get}~~\text{0} \\ &&|&
\text{table.set} &\equiv& \text{table.set}~~\text{0} \\ &&|&
\text{table.size} &\equiv& \text{table.size}~~\text{0} \\ &&|&
\text{table.grow} &\equiv& \text{table.grow}~~\text{0} \\ &&|&
\text{table.fill} &\equiv& \text{table.fill}~~\text{0} \\ &&|&
\text{table.copy} &\equiv& \text{table.copy}~~\text{0}~~\text{0} \\ &&|&
\text{table.init}~~x{:}\Telemidx_I &\equiv& \text{table.init}~~\text{0}~~x{:}\Telemidx_I \\ &&|&
\end{array}


.. index:: memory instruction, memory index
pair: text format; instruction
.. _text-instr-memory:
Expand Down
Loading