See issue #3.

This aligns with current interest in using `mem.` prefix for memory
operations, see #627 and
WebAssembly/threads#62 (comment).

Also remove some of the stuff from the bulk memory proposal that really
should be written in the spec ReST files.

I think it's a better name than `set`, especially considering we may have a `table.set` in the future, which will likely set just one value.

It also follows naming of [Array.prototype.fill](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) which has similar behavior.

Also fix some typos I noticed.

This follows the naming discussed in issue
#627.

* [spec] Initial documentation of syntax

Includes the basic structure needed for the proposal, but no validation,
binary, text or execution.

Using `memory.init` or `memory.drop` on an active segment is a validation error, not a trap.

The current state seems to remove the placeholder table/memory index from the encoding to use it as an active flag.

…mory.init`, `memory.drop`, `table.init`, and `table.drop` identify passive segments; only that they index a valid segment. (#31)

I recently looked into adding support for bulk memory operations into
some Rust tooling in preparation for an overall threading story, and on
reading the overview here I was slightly confused about a few encodings
and some semantics. In the end I'm hopeful that these updates can help
clarify these for future readers! No major functional change is intended
here, only tweaks to wording and clarification of what I believe the
original intent of the instructions were.

Changes made were:

* Fixed a broken `modules.html` link
* Clarified some wording about how the new encoding of data segments
  with a flags field up front is backwards compatible.
* Lifted the style of specifying encodings in `BinaryEncoding.md` to
  replace the current table for the new encoding of a data section. (I
  found this to be a bit more readable, but it should be functionally
  the same!)
* Update `memory.*` instructions (and transitively `table.*`) to all be
  succeeded by an immediate index of which memory/table to operate over.
  This should, in the future, allow initializing/dropping data segments
  with multiple memories in play.
* Updated the chart of instruction binary encodings to explicitly
  specify the following immediates of segments and tables.

This commit fixes #34 by specifying that the flags field (which
indicates if a segment is passive) is a `varuint32` instead of a
`uint8`. It was discovered in #34 that the memory index located at that
position today is a `varuint32`, which can be validly encoded as `0x80
0x00` in addition to `0x00` (in addition to a number of other
encodings). This means that if the first field were repurposed as a
single byte of flags, it would break these existing modules that work
today.

It's not currently known how many modules in the wild actually take
advantage of such an encoding, but it's probably better to be safe than
sorry!

Closes #34

* Update Overview.md for element segments

Passive element segments now include an element type, and have a sequence of expressions instead of function indices.

…able.copy`. (#29)

This would make it simpler to extend those instructions to support multiple memories/tables, and copying between different memories/tables.

The current encoding has a single placeholder zero byte for those instructions, which allows extension to multiple memories/tables, but would require a more complicated encoding to add two immediate indices.

Also, rename {get,set}_table to table.{get,set} to sync with name changes in master.

See WebAssembly/reference-types#18, #29, and #36

The order of the `table.init` and `memory.init` immediates should be the index followed by the reserved byte (which is a placeholder for the table or memory index). This matches ordering of immediates in `call_indirect` (type index, followed by table index reserved byte).

`memory.init`, `memory.copy`, `memory.fill`, `table.init`, and `table.copy` should all fail if their ranges are out-of-bounds, even if the count is zero, similar to for active segments. See the discussions here: WebAssembly/design#897, WebAssembly/bulk-memory-operations#11.

* Clarify trapping semantics

See issue #56.

This adds the new operations, as well as the new data and element
segment formats.

Implemented:

* Text parsing/writing
* Binary encoding/decoding
* Validation

TODO:

* Tests
* DataCount section
* Proper encoding of passive element segments (using ref.null etc)
* Evaluation

This uses the same as order as defined in syntax/ast.

Similar to the MVP, a 0-byte access at the end of the region is legal.

This behavior is a breaking change from the v1 spec, but it is unlikely
that any programs depend on it.

`memory.init`, `data.drop`, `table.init`, `elem.drop`, `table.copy`

Also fix writing passive segments in the text format.

It uses instruction encoding instead of assuming that each element is a
function variable:

```
0xd0 -> ref.null
0xd2 x -> ref.func x
```

* The data count section is required if the `memory.init` or `data.drop`
  instructions are used.

* `memory.init` had an off-by-one bug when reading at the end of a segment.

* All instructions that operate on regions need to compare length to 0
  using unsigned comparison (e.g. `I32.gt_u n 0l`).

* Converting length from 32- to 64-bit now uses
  `I64_convert.extend_i32_u`, instead of `Int64.of_int32`, since the
  latter will sign-extend.

* The `table.copy` overlap test now uses an unsigned comparison.

* The passive element text syntax still allows function indexes, e.g.
  `(elem passive $f1 $f2)`.

* Add element type to passive element segments

* Initial test generation code

* Cleanup

* Parameterize

* Cleanup

* Rename

* More tests

* Table copy

* table.init

* More tests

* More memory.init tests

* table.copy

* data.drop and elem.drop

* Updates for the reference interpreter

* Partial memory.fill

* Comment out test for reference interpreter

* Partial OOB for memory_init

* Partial table.init

* Partial OOB for table.copy

* Some binary tests

* Uncontroversial updates

* Test suite updates after discussion with binji

* Binary tests for elem segments

* Fix test bug, update comments

* Remove irrelevant comment

* Support node.js as well

* Refactor type in passive segments

* Make tests more specific

* Add missing eq_ref
* Fix export index computation
* Remove bogus test

* Rename elem/data.drop
* Reorder bulk instructions
* Rename interpreter AST ref constructors to match reftype repo
* Update interpreter README

… op proposal (#35)

Adds table.size, table.grow, table.fill to overview, spec, interpreter, and tests, as decided at recent CG meeting. Also adds a few more tests for table.get and table.set.

Also, change interpreter's segment encoding to match bulk ops proposal, addressing #18. (Not updated in spec yet, since corresponding spec text is still missing from bulk ops proposal.)

Fixes issue #77.

The data count section has a count that must match the number of data segments. If the data count section isn't present, then `memory.init` and `data.drop` cannot be used.

Fixes issue #73.

* Add definition of free index sets
* Simplify datacount side condition
* Explain convention about multiple occurrences of meta variables

The element segment binary format allows for `ref.null` as well as
`ref.func`.

TODO: text format