Update testsuite (#1308)

* Remove `assert_return_func`. This is now handled by using
  `assert_return` with `(ref.func)`.
* The reference types proposal depends on the bulk memory proposal, so
  using `--enable-reference-types` automatically includes
  `--enable-bulk-memory`.
* `table.fill` no longer clamps to the valid range, and instead checks
  before writing anything. This matches the other bulk instructions.

Author: binji

src/binary-writer-spec.cc

@@ -130,7 +130,6 @@ void BinaryWriterSpec::WriteCommandType(const Command& command) {
       "assert_unlinkable",
       "assert_uninstantiable",
       "assert_return",
-      "assert_return_func",
       "assert_trap",
       "assert_exhaustion",
   };
@@ -496,14 +495,6 @@ void BinaryWriterSpec::WriteCommands() {
         break;
       }
 
-      case CommandType::AssertReturnFunc: {
-        auto* assert_return_command = cast<AssertReturnFuncCommand>(command);
-        WriteLocation(assert_return_command->action->loc);
-        WriteSeparator();
-        WriteAction(*assert_return_command->action);
-        break;
-      }
-
       case CommandType::AssertTrap: {
         auto* assert_trap_command = cast<AssertTrapCommand>(command);
         WriteLocation(assert_trap_command->action->loc);

src/feature.cc

@@ -36,4 +36,11 @@ void Features::AddOptions(OptionParser* parser) {
                     [this]() { EnableAll(); });
 }
 
+void Features::UpdateDependencies() {
+  // Reference types requires bulk memory.
+  if (reference_types_enabled_) {
+    bulk_memory_enabled_ = true;
+  }
+}
+
 }  // namespace wabt

src/feature.h

@@ -35,13 +35,18 @@ class Features {
 
 #define WABT_FEATURE(variable, flag, default_, help)              \
   bool variable##_enabled() const { return variable##_enabled_; } \
-  void enable_##variable() { variable##_enabled_ = true; }        \
-  void disable_##variable() { variable##_enabled_ = false; }      \
-  void set_##variable##_enabled(bool value) { variable##_enabled_ = value; }
+  void enable_##variable() { set_##variable##_enabled(true); }    \
+  void disable_##variable() { set_##variable##_enabled(false); }  \
+  void set_##variable##_enabled(bool value) {                     \
+    variable##_enabled_ = value;                                  \
+    UpdateDependencies();                                         \
+  }
 #include "src/feature.def"
 #undef WABT_FEATURE
 
  private:
+  void UpdateDependencies();
+
 #define WABT_FEATURE(variable, flag, default_, help) \
   bool variable##_enabled_ = default_;
 #include "src/feature.def"

src/interp/interp.cc

@@ -1018,23 +1018,6 @@ Result Thread::AtomicRmwCmpxchg(const uint8_t** pc) {
   return Push<ResultValueType>(static_cast<ExtendedType>(read));
 }
 
-// This function is used to clanp the bound for table.fill operations.  This
-// can be removed once the behaviour of table.fill is updated to match the
-// new bulk meory semantics, which is to trap early on OOB.
-// See: https://github.com/webassembly/bulk-memory-operations/issues/111
-static bool ClampToBounds(uint32_t start, uint32_t* length, uint32_t max) {
-  if (start > max) {
-    *length = 0;
-    return false;
-  }
-  uint32_t avail = max - start;
-  if (*length > avail) {
-    *length = avail;
-    return false;
-  }
-  return true;
-}
-
 static bool CheckBounds(uint32_t start, uint32_t length, uint32_t max) {
   if (start > max) {
     return false;
@@ -1144,15 +1127,16 @@ Result Thread::TableGet(const uint8_t** pc) {
 
 Result Thread::TableFill(const uint8_t** pc) {
   Table* table = ReadTable(pc);
-  uint32_t table_size = table->size();
   uint32_t size = Pop<uint32_t>();
   Ref value = static_cast<Ref>(Pop<Ref>());
   uint32_t dst = Pop<uint32_t>();
-  bool ok = ClampToBounds(dst, &size, table_size);
+  bool ok = CheckBounds(dst, size, table->size());
+  if (!ok) {
+    TRAP_MSG(TableAccessOutOfBounds, "table.fill out of bounds");
+  }
   for (uint32_t i = 0; i < size; i++) {
     table->entries[dst+i] = value;
   }
-  TRAP_IF(!ok, TableAccessOutOfBounds);
   return ResultType::Ok;
 }
 

src/ir.h

@@ -1049,7 +1049,6 @@ enum class CommandType {
   AssertUnlinkable,
   AssertUninstantiable,
   AssertReturn,
-  AssertReturnFunc,
   AssertTrap,
   AssertExhaustion,
 
@@ -1105,12 +1104,6 @@ class AssertReturnCommand : public CommandMixin<CommandType::AssertReturn> {
   ConstVector expected;
 };
 
-class AssertReturnFuncCommand
-    : public CommandMixin<CommandType::AssertReturnFunc> {
- public:
-  ActionPtr action;
-};
-
 template <CommandType TypeEnum>
 class AssertTrapCommandBase : public CommandMixin<TypeEnum> {
  public:

src/lexer-keywords.txt

@@ -20,7 +20,6 @@ assert_exhaustion, TokenType::AssertExhaustion
 assert_invalid, TokenType::AssertInvalid
 assert_malformed, TokenType::AssertMalformed
 assert_return, TokenType::AssertReturn
-assert_return_func, TokenType::AssertReturnFunc
 assert_trap, TokenType::AssertTrap
 assert_unlinkable, TokenType::AssertUnlinkable
 atomic.notify, TokenType::AtomicNotify, Opcode::AtomicNotify