diff options
43 files changed, 1370 insertions, 1510 deletions
diff --git a/fuzz-in/wast.dict b/fuzz-in/wast.dict index fedd721e..d9ac252f 100644 --- a/fuzz-in/wast.dict +++ b/fuzz-in/wast.dict @@ -225,7 +225,5 @@ op_assert_malformed="assert_malformed" op_assert_invalid="assert_invalid" op_assert_unlinkable="assert_unlinkable" op_assert_return="assert_return" -op_assert_return_canonical_nan="assert_return_canonical_nan" -op_assert_return_arithmetic_nan="assert_return_arithmetic_nan" op_assert_trap="assert_trap" op_assert_exhaustion="assert_exhaustion" diff --git a/src/binary-writer-spec.cc b/src/binary-writer-spec.cc index 2c169426..d547f7d6 100644 --- a/src/binary-writer-spec.cc +++ b/src/binary-writer-spec.cc @@ -131,8 +131,6 @@ void BinaryWriterSpec::WriteCommandType(const Command& command) { "assert_uninstantiable", "assert_return", "assert_return_func", - "assert_return_canonical_nan", - "assert_return_arithmetic_nan", "assert_trap", "assert_exhaustion", }; @@ -189,7 +187,15 @@ void BinaryWriterSpec::WriteConst(const Const& const_) { WriteString("f32"); WriteSeparator(); WriteKey("value"); - json_stream_->Writef("\"%u\"", const_.f32_bits); + if (const_.is_expected_nan) { + if (const_.expected == ExpectedNan::Arithmetic) { + WriteString("nan:arithmetic"); + } else { + WriteString("nan:canonical"); + } + } else { + json_stream_->Writef("\"%u\"", const_.f32_bits); + } break; } @@ -198,7 +204,15 @@ void BinaryWriterSpec::WriteConst(const Const& const_) { WriteString("f64"); WriteSeparator(); WriteKey("value"); - json_stream_->Writef("\"%" PRIu64 "\"", const_.f64_bits); + if (const_.is_expected_nan) { + if (const_.expected == ExpectedNan::Arithmetic) { + WriteString("nan:arithmetic"); + } else { + WriteString("nan:canonical"); + } + } else { + json_stream_->Writef("\"%" PRIu64 "\"", const_.f64_bits); + } break; } @@ -490,30 +504,6 @@ void BinaryWriterSpec::WriteCommands() { break; } - case CommandType::AssertReturnCanonicalNan: { - auto* assert_return_canonical_nan_command = - cast<AssertReturnCanonicalNanCommand>(command); - WriteLocation(assert_return_canonical_nan_command->action->loc); - WriteSeparator(); - WriteAction(*assert_return_canonical_nan_command->action); - WriteSeparator(); - WriteKey("expected"); - WriteActionResultType(*assert_return_canonical_nan_command->action); - break; - } - - case CommandType::AssertReturnArithmeticNan: { - auto* assert_return_arithmetic_nan_command = - cast<AssertReturnArithmeticNanCommand>(command); - WriteLocation(assert_return_arithmetic_nan_command->action->loc); - WriteSeparator(); - WriteAction(*assert_return_arithmetic_nan_command->action); - WriteSeparator(); - WriteKey("expected"); - WriteActionResultType(*assert_return_arithmetic_nan_command->action); - break; - } - case CommandType::AssertTrap: { auto* assert_trap_command = cast<AssertTrapCommand>(command); WriteLocation(assert_trap_command->action->loc); diff --git a/src/common.h b/src/common.h index a01b2989..6437bb7a 100644 --- a/src/common.h +++ b/src/common.h @@ -235,6 +235,12 @@ enum class SegmentKind { Declared, }; +// Used in test asserts for special expected values "nan:canonical" and "nan:arithmetic" +enum class ExpectedNan { + Canonical, + Arithmetic, +}; + // Matches binary format, do not change. enum SegmentFlags : uint8_t { SegFlagsNone = 0, diff --git a/src/interp/binary-reader-interp.cc b/src/interp/binary-reader-interp.cc index 3f270abf..5312e78b 100644 --- a/src/interp/binary-reader-interp.cc +++ b/src/interp/binary-reader-interp.cc @@ -1130,11 +1130,6 @@ wabt::Result BinaryReaderInterp::OnElemSegmentElemExprCount(Index index, if (segment_flags_ & SegPassive) { elem_segment_info_ = nullptr; } else { - // An active segment still is present in the segment index space, but - // cannot be used with `table.init` (it's as if it has already been - // dropped). - elem_segment_->dropped = true; - assert(segment_table_index_ != kInvalidIndex); Table* table = GetTableByModuleIndex(segment_table_index_); module_->active_elem_segments_.emplace_back(table, table_offset_); @@ -1146,7 +1141,11 @@ wabt::Result BinaryReaderInterp::OnElemSegmentElemExprCount(Index index, wabt::Result BinaryReaderInterp::OnElemSegmentElemExpr_RefNull( Index segment_index) { assert(segment_flags_ & SegUseElemExprs); - elem_segment_->elems.push_back({RefType::Null, kInvalidIndex}); + if (segment_flags_ & SegPassive) { + elem_segment_->elems.push_back({RefType::Null, kInvalidIndex}); + } else { + elem_segment_info_->src.push_back({RefType::Null, kInvalidIndex}); + } return wabt::Result::Ok; } @@ -1207,11 +1206,6 @@ wabt::Result BinaryReaderInterp::OnDataSegmentData(Index index, return wabt::Result::Error; } - // An active segment still is present in the segment index space, but - // cannot be used with `memory.init` (it's as if it has already been - // dropped). - segment->dropped = true; - assert(module_->memory_index != kInvalidIndex); Memory* memory = env_->GetMemory(module_->memory_index); Address address = init_expr_value_.value.i32; diff --git a/src/interp/interp.cc b/src/interp/interp.cc index a3d621e7..61e9d98b 100644 --- a/src/interp/interp.cc +++ b/src/interp/interp.cc @@ -1018,7 +1018,11 @@ Result Thread::AtomicRmwCmpxchg(const uint8_t** pc) { return Push<ResultValueType>(static_cast<ExtendedType>(read)); } -bool ClampToBounds(uint32_t start, uint32_t* length, uint32_t max) { +// 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; @@ -1031,6 +1035,14 @@ bool ClampToBounds(uint32_t start, uint32_t* length, uint32_t max) { return true; } +static bool CheckBounds(uint32_t start, uint32_t length, uint32_t max) { + if (start > max) { + return false; + } + uint32_t avail = max - start; + return length <= avail; +} + Result Thread::MemoryInit(const uint8_t** pc) { Memory* memory = ReadMemory(pc); DataSegment* segment = ReadDataSegment(pc); @@ -1039,13 +1051,12 @@ Result Thread::MemoryInit(const uint8_t** pc) { uint32_t size = Pop<uint32_t>(); uint32_t src = Pop<uint32_t>(); uint32_t dst = Pop<uint32_t>(); + bool ok = CheckBounds(dst, size, memory_size); + ok &= CheckBounds(src, size, segment_size); + if (!ok) { + TRAP_MSG(MemoryAccessOutOfBounds, "memory.init out of bounds"); + } if (size > 0) { - TRAP_IF(segment->dropped, DataSegmentDropped); - bool ok = ClampToBounds(dst, &size, memory_size); - ok &= ClampToBounds(src, &size, segment_size); - if (!ok) { - TRAP_MSG(MemoryAccessOutOfBounds, "memory.init out of bounds"); - } memcpy(memory->data.data() + dst, segment->data.data() + src, size); } return ResultType::Ok; @@ -1053,8 +1064,7 @@ Result Thread::MemoryInit(const uint8_t** pc) { Result Thread::DataDrop(const uint8_t** pc) { DataSegment* segment = ReadDataSegment(pc); - TRAP_IF(segment->dropped, DataSegmentDropped); - segment->dropped = true; + segment->data.clear(); return ResultType::Ok; } @@ -1064,12 +1074,12 @@ Result Thread::MemoryCopy(const uint8_t** pc) { uint32_t size = Pop<uint32_t>(); uint32_t src = Pop<uint32_t>(); uint32_t dst = Pop<uint32_t>(); + bool ok = CheckBounds(dst, size, memory_size); + ok &= CheckBounds(src, size, memory_size); + if (!ok) { + TRAP_MSG(MemoryAccessOutOfBounds, "memory.copy out of bound"); + } if (size > 0) { - bool ok = ClampToBounds(dst, &size, memory_size); - ok &= ClampToBounds(src, &size, memory_size); - if (!ok) { - TRAP_MSG(MemoryAccessOutOfBounds, "memory.copy out of bound"); - } char* data = memory->data.data(); memmove(data + dst, data + src, size); } @@ -1082,11 +1092,10 @@ Result Thread::MemoryFill(const uint8_t** pc) { uint32_t size = Pop<uint32_t>(); uint8_t value = static_cast<uint8_t>(Pop<uint32_t>()); uint32_t dst = Pop<uint32_t>(); + if (!CheckBounds(dst, size, memory_size)) { + TRAP_MSG(MemoryAccessOutOfBounds, "memory.fill out of bounds"); + } if (size > 0) { - bool ok = ClampToBounds(dst, &size, memory_size); - if (!ok) { - TRAP_MSG(MemoryAccessOutOfBounds, "memory.fill out of bounds"); - } memset(memory->data.data() + dst, value, size); } return ResultType::Ok; @@ -1099,13 +1108,12 @@ Result Thread::TableInit(const uint8_t** pc) { uint32_t size = Pop<uint32_t>(); uint32_t src = Pop<uint32_t>(); uint32_t dst = Pop<uint32_t>(); + bool ok = CheckBounds(dst, size, table->size()); + ok &= CheckBounds(src, size, segment_size); + if (!ok) { + TRAP_MSG(TableAccessOutOfBounds, "table.init out of bounds"); + } if (size > 0) { - TRAP_IF(segment->dropped, ElemSegmentDropped); - bool ok = ClampToBounds(dst, &size, table->size()); - ok &= ClampToBounds(src, &size, segment_size); - if (!ok) { - TRAP_MSG(TableAccessOutOfBounds, "table.init out of bounds"); - } memcpy(table->entries.data() + dst, segment->elems.data() + src, size * sizeof(table->entries[0])); } @@ -1144,14 +1152,13 @@ Result Thread::TableFill(const uint8_t** pc) { for (uint32_t i = 0; i < size; i++) { table->entries[dst+i] = value; } - TRAP_IF(!ok, MemoryAccessOutOfBounds); + TRAP_IF(!ok, TableAccessOutOfBounds); return ResultType::Ok; } Result Thread::ElemDrop(const uint8_t** pc) { ElemSegment* segment = ReadElemSegment(pc); - TRAP_IF(segment->dropped, ElemSegmentDropped); - segment->dropped = true; + segment->elems.clear(); return ResultType::Ok; } @@ -1162,12 +1169,12 @@ Result Thread::TableCopy(const uint8_t** pc) { uint32_t size = Pop<uint32_t>(); uint32_t src = Pop<uint32_t>(); uint32_t dst = Pop<uint32_t>(); + bool ok = CheckBounds(dst, size, dst_table->size()); + ok &= CheckBounds(src, size, dst_table->size()); + if (!ok) { + TRAP_MSG(TableAccessOutOfBounds, "table.copy out of bounds"); + } if (size > 0) { - bool ok = ClampToBounds(dst, &size, dst_table->size()); - ok &= ClampToBounds(src, &size, dst_table->size()); - if (!ok) { - TRAP_MSG(TableAccessOutOfBounds, "table.copy out of bounds"); - } Ref* data_src = src_table->entries.data(); Ref* data_dst = dst_table->entries.data(); memmove(data_dst + dst, data_src + src, size * sizeof(Ref)); @@ -3755,40 +3762,36 @@ Result Executor::InitializeSegments(DefinedModule* module) { uint32_t table_size = info.table->size(); uint32_t segment_size = info.src.size(); uint32_t copy_size = segment_size; - bool ok = ClampToBounds(info.dst, ©_size, table_size); - - if (pass == Init && copy_size > 0) { - std::copy(info.src.begin(), info.src.begin() + copy_size, - info.table->entries.begin() + info.dst); - } - - if (!ok) { + if (!CheckBounds(info.dst, copy_size, table_size)) { TRAP_MSG(TableAccessOutOfBounds, "elem segment is out of bounds: [%u, %" PRIu64 ") >= max value %u", info.dst, static_cast<uint64_t>(info.dst) + segment_size, table_size); } + + if (pass == Init && copy_size > 0) { + std::copy(info.src.begin(), info.src.begin() + copy_size, + info.table->entries.begin() + info.dst); + } } for (const DataSegmentInfo& info : module->active_data_segments_) { uint32_t memory_size = info.memory->data.size(); uint32_t segment_size = info.data.size(); uint32_t copy_size = segment_size; - bool ok = ClampToBounds(info.dst, ©_size, memory_size); - - if (pass == Init && copy_size > 0) { - std::copy(info.data.begin(), info.data.begin() + copy_size, - info.memory->data.begin() + info.dst); - } - - if (!ok) { + if (!CheckBounds(info.dst, copy_size, memory_size)) { TRAP_MSG(MemoryAccessOutOfBounds, "data segment is out of bounds: [%u, %" PRIu64 ") >= max value %u", info.dst, static_cast<uint64_t>(info.dst) + segment_size, memory_size); } + + if (pass == Init && copy_size > 0) { + std::copy(info.data.begin(), info.data.begin() + copy_size, + info.memory->data.begin() + info.dst); + } } } diff --git a/src/interp/interp.h b/src/interp/interp.h index 7d01fb9a..e7bb1e25 100644 --- a/src/interp/interp.h +++ b/src/interp/interp.h @@ -66,10 +66,6 @@ namespace interp { V(TrapHostResultTypeMismatch, "host result type mismatch") \ /* we called an import function, but it didn't complete succesfully */ \ V(TrapHostTrapped, "host function trapped") \ - /* the data segment has been dropped. */ \ - V(TrapDataSegmentDropped, "data segment dropped") \ - /* the element segment has been dropped. */ \ - V(TrapElemSegmentDropped, "element segment dropped") \ /* table access is out of bounds */ \ V(TrapTableAccessOutOfBounds, "out of bounds table access") \ /* we attempted to call a function with the an argument list that doesn't \ @@ -150,14 +146,12 @@ struct DataSegment { DataSegment() = default; std::vector<char> data; - bool dropped = false; }; struct ElemSegment { ElemSegment() = default; std::vector<Ref> elems; - bool dropped = false; }; struct ElemSegmentInfo { @@ -208,7 +202,7 @@ union Value { }; struct TypedValue { - TypedValue() {} + TypedValue() = default; explicit TypedValue(Type type) : type(type) {} TypedValue(Type basetype, const Value& value) : type(basetype), value(value) { UpdateType(); @@ -780,8 +774,6 @@ std::string TypedValueToString(const TypedValue&); std::string ResultToString(Result); const char* ResultTypeToString(ResultType); -bool ClampToBounds(uint32_t start, uint32_t* length, uint32_t max); - void WriteTypedValue(Stream* stream, const TypedValue&); void WriteTypedValues(Stream* stream, const TypedValues&); void WriteResult(Stream* stream, const char* desc, Result); @@ -98,6 +98,8 @@ struct Const { Location loc; Type type; + + bool is_expected_nan = false; union { uint32_t u32; uint64_t u64; @@ -105,6 +107,7 @@ struct Const { uint64_t f64_bits; uintptr_t ref_bits; v128 vec128; + ExpectedNan expected; }; private: @@ -1047,8 +1050,6 @@ enum class CommandType { AssertUninstantiable, AssertReturn, AssertReturnFunc, - AssertReturnCanonicalNan, - AssertReturnArithmeticNan, AssertTrap, AssertExhaustion, @@ -1088,10 +1089,6 @@ class ActionCommandBase : public CommandMixin<TypeEnum> { }; typedef ActionCommandBase<CommandType::Action> ActionCommand; -typedef ActionCommandBase<CommandType::AssertReturnCanonicalNan> - AssertReturnCanonicalNanCommand; -typedef ActionCommandBase<CommandType::AssertReturnArithmeticNan> - AssertReturnArithmeticNanCommand; class RegisterCommand : public CommandMixin<CommandType::Register> { public: diff --git a/src/lexer-keywords.txt b/src/lexer-keywords.txt index 6d560e24..7933487a 100644 --- a/src/lexer-keywords.txt +++ b/src/lexer-keywords.txt @@ -19,8 +19,6 @@ anyref, Type::Anyref assert_exhaustion, TokenType::AssertExhaustion assert_invalid, TokenType::AssertInvalid assert_malformed, TokenType::AssertMalformed -assert_return_arithmetic_nan, TokenType::AssertReturnArithmeticNan -assert_return_canonical_nan, TokenType::AssertReturnCanonicalNan assert_return, TokenType::AssertReturn assert_return_func, TokenType::AssertReturnFunc assert_trap, TokenType::AssertTrap @@ -441,6 +439,8 @@ memory.size, TokenType::MemorySize, Opcode::MemorySize memory, TokenType::Memory module, TokenType::Module mut, TokenType::Mut +nan:arithmetic, TokenType::NanArithmetic +nan:canonical, TokenType::NanCanonical nop, TokenType::Nop, Opcode::Nop nullref, Type::Nullref offset, TokenType::Offset diff --git a/src/prebuilt/lexer-keywords.cc b/src/prebuilt/lexer-keywords.cc index d504e139..aa162a25 100644 --- a/src/prebuilt/lexer-keywords.cc +++ b/src/prebuilt/lexer-keywords.cc @@ -152,7 +152,7 @@ Perfect_Hash::InWordSet (const char *str, size_t len) { TOTAL_KEYWORDS = 507, MIN_WORD_LENGTH = 2, - MAX_WORD_LENGTH = 28, + MAX_WORD_LENGTH = 26, MIN_HASH_VALUE = 17, MAX_HASH_VALUE = 1733 }; @@ -161,128 +161,128 @@ Perfect_Hash::InWordSet (const char *str, size_t len) { {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 428 "src/lexer-keywords.txt" +#line 426 "src/lexer-keywords.txt" {"if", TokenType::If, Opcode::If}, {""}, {""}, {""}, -#line 128 "src/lexer-keywords.txt" +#line 126 "src/lexer-keywords.txt" {"f64", Type::F64}, -#line 443 "src/lexer-keywords.txt" +#line 441 "src/lexer-keywords.txt" {"mut", TokenType::Mut}, -#line 77 "src/lexer-keywords.txt" +#line 75 "src/lexer-keywords.txt" {"f32", Type::F32}, -#line 382 "src/lexer-keywords.txt" +#line 380 "src/lexer-keywords.txt" {"i64", Type::I64}, {""}, -#line 262 "src/lexer-keywords.txt" +#line 260 "src/lexer-keywords.txt" {"i32", Type::I32}, {""}, {""}, {""}, #line 470 "src/lexer-keywords.txt" {"then", TokenType::Then}, {""}, {""}, {""}, -#line 44 "src/lexer-keywords.txt" +#line 42 "src/lexer-keywords.txt" {"else", TokenType::Else, Opcode::Else}, -#line 43 "src/lexer-keywords.txt" +#line 41 "src/lexer-keywords.txt" {"elem", TokenType::Elem}, {""}, -#line 115 "src/lexer-keywords.txt" +#line 113 "src/lexer-keywords.txt" {"f64.lt", TokenType::Compare, Opcode::F64Lt}, -#line 65 "src/lexer-keywords.txt" +#line 63 "src/lexer-keywords.txt" {"f32.lt", TokenType::Compare, Opcode::F32Lt}, {""}, {""}, {""}, {""}, -#line 46 "src/lexer-keywords.txt" +#line 44 "src/lexer-keywords.txt" {"event", TokenType::Event}, {""}, #line 461 "src/lexer-keywords.txt" {"start", TokenType::Start}, {""}, {""}, {""}, -#line 113 "src/lexer-keywords.txt" +#line 111 "src/lexer-keywords.txt" {"f64.le", TokenType::Compare, Opcode::F64Le}, -#line 63 "src/lexer-keywords.txt" +#line 61 "src/lexer-keywords.txt" {"f32.le", TokenType::Compare, Opcode::F32Le}, -#line 150 "src/lexer-keywords.txt" +#line 148 "src/lexer-keywords.txt" {"funcref", Type::Funcref}, -#line 117 "src/lexer-keywords.txt" +#line 115 "src/lexer-keywords.txt" {"f64.min", TokenType::Binary, Opcode::F64Min}, -#line 67 "src/lexer-keywords.txt" +#line 65 "src/lexer-keywords.txt" {"f32.min", TokenType::Binary, Opcode::F32Min}, -#line 355 "src/lexer-keywords.txt" +#line 353 "src/lexer-keywords.txt" {"i64.lt_s", TokenType::Compare, Opcode::I64LtS}, -#line 236 "src/lexer-keywords.txt" +#line 234 "src/lexer-keywords.txt" {"i32.lt_s", TokenType::Compare, Opcode::I32LtS}, #line 469 "src/lexer-keywords.txt" {"table", TokenType::Table}, {""}, -#line 356 "src/lexer-keywords.txt" +#line 354 "src/lexer-keywords.txt" {"i64.lt_u", TokenType::Compare, Opcode::I64LtU}, -#line 237 "src/lexer-keywords.txt" +#line 235 "src/lexer-keywords.txt" {"i32.lt_u", TokenType::Compare, Opcode::I32LtU}, -#line 346 "src/lexer-keywords.txt" +#line 344 "src/lexer-keywords.txt" {"i64.le_s", TokenType::Compare, Opcode::I64LeS}, -#line 229 "src/lexer-keywords.txt" +#line 227 "src/lexer-keywords.txt" {"i32.le_s", TokenType::Compare, Opcode::I32LeS}, {""}, {""}, -#line 347 "src/lexer-keywords.txt" +#line 345 "src/lexer-keywords.txt" {"i64.le_u", TokenType::Compare, Opcode::I64LeU}, -#line 230 "src/lexer-keywords.txt" +#line 228 "src/lexer-keywords.txt" {"i32.le_u", TokenType::Compare, Opcode::I32LeU}, #line 446 "src/lexer-keywords.txt" {"offset", TokenType::Offset}, -#line 362 "src/lexer-keywords.txt" +#line 360 "src/lexer-keywords.txt" {"i64.rem_s", TokenType::Binary, Opcode::I64RemS}, -#line 243 "src/lexer-keywords.txt" +#line 241 "src/lexer-keywords.txt" {"i32.rem_s", TokenType::Binary, Opcode::I32RemS}, {""}, {""}, -#line 363 "src/lexer-keywords.txt" +#line 361 "src/lexer-keywords.txt" {"i64.rem_u", TokenType::Binary, Opcode::I64RemU}, -#line 244 "src/lexer-keywords.txt" +#line 242 "src/lexer-keywords.txt" {"i32.rem_u", TokenType::Binary, Opcode::I32RemU}, {""}, {""}, #line 445 "src/lexer-keywords.txt" {"nullref", Type::Nullref}, {""}, {""}, -#line 121 "src/lexer-keywords.txt" +#line 119 "src/lexer-keywords.txt" {"f64.ne", TokenType::Compare, Opcode::F64Ne}, -#line 71 "src/lexer-keywords.txt" +#line 69 "src/lexer-keywords.txt" {"f32.ne", TokenType::Compare, Opcode::F32Ne}, -#line 40 "src/lexer-keywords.txt" +#line 38 "src/lexer-keywords.txt" {"data", TokenType::Data}, -#line 358 "src/lexer-keywords.txt" +#line 356 "src/lexer-keywords.txt" {"i64.ne", TokenType::Compare, Opcode::I64Ne}, -#line 239 "src/lexer-keywords.txt" +#line 237 "src/lexer-keywords.txt" {"i32.ne", TokenType::Compare, Opcode::I32Ne}, {""}, {""}, -#line 99 "src/lexer-keywords.txt" +#line 97 "src/lexer-keywords.txt" {"f64.abs", TokenType::Unary, Opcode::F64Abs}, -#line 48 "src/lexer-keywords.txt" +#line 46 "src/lexer-keywords.txt" {"f32.abs", TokenType::Unary, Opcode::F32Abs}, -#line 126 "src/lexer-keywords.txt" +#line 124 "src/lexer-keywords.txt" {"f64.sub", TokenType::Binary, Opcode::F64Sub}, -#line 75 "src/lexer-keywords.txt" +#line 73 "src/lexer-keywords.txt" {"f32.sub", TokenType::Binary, Opcode::F32Sub}, {""}, -#line 373 "src/lexer-keywords.txt" +#line 371 "src/lexer-keywords.txt" {"i64.sub", TokenType::Binary, Opcode::I64Sub}, -#line 253 "src/lexer-keywords.txt" +#line 251 "src/lexer-keywords.txt" {"i32.sub", TokenType::Binary, Opcode::I32Sub}, {""}, {""}, -#line 442 "src/lexer-keywords.txt" +#line 440 "src/lexer-keywords.txt" {"module", TokenType::Module}, -#line 118 "src/lexer-keywords.txt" +#line 116 "src/lexer-keywords.txt" {"f64.mul", TokenType::Binary, Opcode::F64Mul}, -#line 68 "src/lexer-keywords.txt" +#line 66 "src/lexer-keywords.txt" {"f32.mul", TokenType::Binary, Opcode::F32Mul}, {""}, -#line 357 "src/lexer-keywords.txt" +#line 355 "src/lexer-keywords.txt" {"i64.mul", TokenType::Binary, Opcode::I64Mul}, -#line 238 "src/lexer-keywords.txt" +#line 236 "src/lexer-keywords.txt" {"i32.mul", TokenType::Binary, Opcode::I32Mul}, {""}, {""}, {""}, {""}, #line 459 "src/lexer-keywords.txt" {"select", TokenType::Select, Opcode::Select}, -#line 30 "src/lexer-keywords.txt" +#line 28 "src/lexer-keywords.txt" {"block", TokenType::Block, Opcode::Block}, {""}, -#line 34 "src/lexer-keywords.txt" +#line 32 "src/lexer-keywords.txt" {"br", TokenType::Br, Opcode::Br}, {""}, #line 454 "src/lexer-keywords.txt" @@ -294,149 +294,149 @@ Perfect_Hash::InWordSet (const char *str, size_t len) {"return", TokenType::Return, Opcode::Return}, #line 465 "src/lexer-keywords.txt" {"table.init", TokenType::TableInit, Opcode::TableInit}, -#line 151 "src/lexer-keywords.txt" +#line 149 "src/lexer-keywords.txt" {"func", TokenType::Func}, -#line 45 "src/lexer-keywords.txt" +#line 43 "src/lexer-keywords.txt" {"end", TokenType::End, Opcode::End}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 333 "src/lexer-keywords.txt" +#line 331 "src/lexer-keywords.txt" {"i64.div_s", TokenType::Binary, Opcode::I64DivS}, -#line 219 "src/lexer-keywords.txt" +#line 217 "src/lexer-keywords.txt" {"i32.div_s", TokenType::Binary, Opcode::I32DivS}, {""}, {""}, -#line 334 "src/lexer-keywords.txt" +#line 332 "src/lexer-keywords.txt" {"i64.div_u", TokenType::Binary, Opcode::I64DivU}, -#line 220 "src/lexer-keywords.txt" +#line 218 "src/lexer-keywords.txt" {"i32.div_u", TokenType::Binary, Opcode::I32DivU}, -#line 430 "src/lexer-keywords.txt" +#line 428 "src/lexer-keywords.txt" {"invoke", TokenType::Invoke}, -#line 364 "src/lexer-keywords.txt" +#line 362 "src/lexer-keywords.txt" {"i64.rotl", TokenType::Binary, Opcode::I64Rotl}, -#line 245 "src/lexer-keywords.txt" +#line 243 "src/lexer-keywords.txt" {"i32.rotl", TokenType::Binary, Opcode::I32Rotl}, -#line 102 "src/lexer-keywords.txt" +#line 100 "src/lexer-keywords.txt" {"f64.const", TokenType::Const, Opcode::F64Const}, -#line 51 "src/lexer-keywords.txt" +#line 49 "src/lexer-keywords.txt" {"f32.const", TokenType::Const, Opcode::F32Const}, {""}, -#line 331 "src/lexer-keywords.txt" +#line 329 "src/lexer-keywords.txt" {"i64.const", TokenType::Const, Opcode::I64Const}, -#line 217 "src/lexer-keywords.txt" +#line 215 "src/lexer-keywords.txt" {"i32.const", TokenType::Const, Opcode::I32Const}, #line 460 "src/lexer-keywords.txt" {"shared", TokenType::Shared}, {""}, {""}, -#line 149 "src/lexer-keywords.txt" +#line 147 "src/lexer-keywords.txt" {"f64x2", TokenType::F64X2}, {""}, {""}, -#line 395 "src/lexer-keywords.txt" +#line 393 "src/lexer-keywords.txt" {"i64x2", TokenType::I64X2}, {""}, {""}, {""}, {""}, -#line 33 "src/lexer-keywords.txt" +#line 31 "src/lexer-keywords.txt" {"br_table", TokenType::BrTable, Opcode::BrTable}, {""}, -#line 101 "src/lexer-keywords.txt" +#line 99 "src/lexer-keywords.txt" {"f64.ceil", TokenType::Unary, Opcode::F64Ceil}, -#line 50 "src/lexer-keywords.txt" +#line 48 "src/lexer-keywords.txt" {"f32.ceil", TokenType::Unary, Opcode::F32Ceil}, {""}, {""}, #line 452 "src/lexer-keywords.txt" {"ref.host", TokenType::RefHost}, #line 468 "src/lexer-keywords.txt" {"table.fill", TokenType::TableFill, Opcode::TableFill}, -#line 292 "src/lexer-keywords.txt" +#line 290 "src/lexer-keywords.txt" {"i64.and", TokenType::Binary, Opcode::I64And}, -#line 187 "src/lexer-keywords.txt" +#line 185 "src/lexer-keywords.txt" {"i32.and", TokenType::Binary, Opcode::I32And}, {""}, -#line 36 "src/lexer-keywords.txt" +#line 34 "src/lexer-keywords.txt" {"call", TokenType::Call, Opcode::Call}, {""}, -#line 108 "src/lexer-keywords.txt" +#line 106 "src/lexer-keywords.txt" {"f64.div", TokenType::Binary, Opcode::F64Div}, -#line 58 "src/lexer-keywords.txt" +#line 56 "src/lexer-keywords.txt" {"f32.div", TokenType::Binary, Opcode::F32Div}, {""}, {""}, {""}, {""}, -#line 434 "src/lexer-keywords.txt" +#line 432 "src/lexer-keywords.txt" {"local", TokenType::Local}, -#line 27 "src/lexer-keywords.txt" +#line 25 "src/lexer-keywords.txt" {"assert_unlinkable", TokenType::AssertUnlinkable}, {""}, -#line 125 "src/lexer-keywords.txt" +#line 123 "src/lexer-keywords.txt" {"f64.store", TokenType::Store, Opcode::F64Store}, -#line 74 "src/lexer-keywords.txt" +#line 72 "src/lexer-keywords.txt" {"f32.store", TokenType::Store, Opcode::F32Store}, {""}, -#line 372 "src/lexer-keywords.txt" +#line 370 "src/lexer-keywords.txt" {"i64.store", TokenType::Store, Opcode::I64Store}, -#line 252 "src/lexer-keywords.txt" +#line 250 "src/lexer-keywords.txt" {"i32.store", TokenType::Store, Opcode::I32Store}, {""}, {""}, -#line 370 "src/lexer-keywords.txt" +#line 368 "src/lexer-keywords.txt" {"i64.store32", TokenType::Store, Opcode::I64Store32}, {""}, {""}, {""}, {""}, -#line 114 "src/lexer-keywords.txt" +#line 112 "src/lexer-keywords.txt" {"f64.load", TokenType::Load, Opcode::F64Load}, -#line 64 "src/lexer-keywords.txt" +#line 62 "src/lexer-keywords.txt" {"f32.load", TokenType::Load, Opcode::F32Load}, #line 455 "src/lexer-keywords.txt" {"rethrow", TokenType::Rethrow, Opcode::Rethrow}, -#line 354 "src/lexer-keywords.txt" +#line 352 "src/lexer-keywords.txt" {"i64.load", TokenType::Load, Opcode::I64Load}, -#line 235 "src/lexer-keywords.txt" +#line 233 "src/lexer-keywords.txt" {"i32.load", TokenType::Load, Opcode::I32Load}, {""}, {""}, {""}, {""}, {""}, -#line 119 "src/lexer-keywords.txt" +#line 117 "src/lexer-keywords.txt" {"f64.nearest", TokenType::Unary, Opcode::F64Nearest}, -#line 69 "src/lexer-keywords.txt" +#line 67 "src/lexer-keywords.txt" {"f32.nearest", TokenType::Unary, Opcode::F32Nearest}, {""}, -#line 100 "src/lexer-keywords.txt" +#line 98 "src/lexer-keywords.txt" {"f64.add", TokenType::Binary, Opcode::F64Add}, -#line 49 "src/lexer-keywords.txt" +#line 47 "src/lexer-keywords.txt" {"f32.add", TokenType::Binary, Opcode::F32Add}, {""}, -#line 291 "src/lexer-keywords.txt" +#line 289 "src/lexer-keywords.txt" {"i64.add", TokenType::Binary, Opcode::I64Add}, -#line 186 "src/lexer-keywords.txt" +#line 184 "src/lexer-keywords.txt" {"i32.add", TokenType::Binary, Opcode::I32Add}, -#line 144 "src/lexer-keywords.txt" +#line 142 "src/lexer-keywords.txt" {"f64x2.ne", TokenType::Compare, Opcode::F64X2Ne}, -#line 141 "src/lexer-keywords.txt" +#line 139 "src/lexer-keywords.txt" {"f64x2.min", TokenType::Binary, Opcode::F64X2Min}, {""}, -#line 432 "src/lexer-keywords.txt" +#line 430 "src/lexer-keywords.txt" {"local.set", TokenType::LocalSet, Opcode::LocalSet}, {""}, {""}, {""}, -#line 329 "src/lexer-keywords.txt" +#line 327 "src/lexer-keywords.txt" {"i64.atomic.wait", TokenType::AtomicWait, Opcode::I64AtomicWait}, -#line 215 "src/lexer-keywords.txt" +#line 213 "src/lexer-keywords.txt" {"i32.atomic.wait", TokenType::AtomicWait, Opcode::I32AtomicWait}, #line 450 "src/lexer-keywords.txt" {"ref.is_null", TokenType::RefIsNull, Opcode::RefIsNull}, -#line 139 "src/lexer-keywords.txt" +#line 137 "src/lexer-keywords.txt" {"f64x2.lt", TokenType::Compare, Opcode::F64X2Lt}, {""}, {""}, {""}, {""}, -#line 433 "src/lexer-keywords.txt" +#line 431 "src/lexer-keywords.txt" {"local.tee", TokenType::LocalTee, Opcode::LocalTee}, {""}, {""}, {""}, -#line 328 "src/lexer-keywords.txt" +#line 326 "src/lexer-keywords.txt" {"i64.atomic.store", TokenType::AtomicStore, Opcode::I64AtomicStore}, -#line 214 "src/lexer-keywords.txt" +#line 212 "src/lexer-keywords.txt" {"i32.atomic.store", TokenType::AtomicStore, Opcode::I32AtomicStore}, {""}, -#line 138 "src/lexer-keywords.txt" +#line 136 "src/lexer-keywords.txt" {"f64x2.le", TokenType::Compare, Opcode::F64X2Le}, {""}, {""}, #line 451 "src/lexer-keywords.txt" {"ref.null", TokenType::RefNull, Opcode::RefNull}, -#line 365 "src/lexer-keywords.txt" +#line 363 "src/lexer-keywords.txt" {"i64.rotr", TokenType::Binary, Opcode::I64Rotr}, -#line 246 "src/lexer-keywords.txt" +#line 244 "src/lexer-keywords.txt" {"i32.rotr", TokenType::Binary, Opcode::I32Rotr}, -#line 129 "src/lexer-keywords.txt" +#line 127 "src/lexer-keywords.txt" {"f64x2.abs", TokenType::Unary, Opcode::F64X2Abs}, -#line 326 "src/lexer-keywords.txt" +#line 324 "src/lexer-keywords.txt" {"i64.atomic.store32", TokenType::AtomicStore, Opcode::I64AtomicStore32}, #line 467 "src/lexer-keywords.txt" {"table.size", TokenType::TableSize, Opcode::TableSize}, @@ -444,193 +444,194 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 20 "src/lexer-keywords.txt" {"assert_invalid", TokenType::AssertInvalid}, {""}, {""}, {""}, -#line 148 "src/lexer-keywords.txt" +#line 146 "src/lexer-keywords.txt" {"f64x2.sub", TokenType::Binary, Opcode::F64X2Sub}, {""}, #line 524 "src/lexer-keywords.txt" {"set_local", TokenType::LocalSet, Opcode::LocalSet}, -#line 394 "src/lexer-keywords.txt" +#line 392 "src/lexer-keywords.txt" {"i64x2.sub", TokenType::Binary, Opcode::I64X2Sub}, {""}, {""}, {""}, -#line 142 "src/lexer-keywords.txt" +#line 140 "src/lexer-keywords.txt" {"f64x2.mul", TokenType::Binary, Opcode::F64X2Mul}, #line 525 "src/lexer-keywords.txt" {"tee_local", TokenType::LocalTee, Opcode::LocalTee}, {""}, {""}, -#line 24 "src/lexer-keywords.txt" +#line 22 "src/lexer-keywords.txt" {"assert_return", TokenType::AssertReturn}, {""}, {""}, #line 473 "src/lexer-keywords.txt" {"type", TokenType::Type}, {""}, {""}, {""}, -#line 57 "src/lexer-keywords.txt" +#line 55 "src/lexer-keywords.txt" {"f32.demote_f64", TokenType::Convert, Opcode::F32DemoteF64}, #line 479 "src/lexer-keywords.txt" {"v128.not", TokenType::Unary, Opcode::V128Not}, {""}, {""}, {""}, {""}, {""}, -#line 429 "src/lexer-keywords.txt" +#line 427 "src/lexer-keywords.txt" {"import", TokenType::Import}, {""}, {""}, -#line 47 "src/lexer-keywords.txt" +#line 45 "src/lexer-keywords.txt" {"export", TokenType::Export}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 350 "src/lexer-keywords.txt" +#line 348 "src/lexer-keywords.txt" {"i64.load32_s", TokenType::Load, Opcode::I64Load32S}, {""}, {""}, {""}, -#line 351 "src/lexer-keywords.txt" +#line 349 "src/lexer-keywords.txt" {"i64.load32_u", TokenType::Load, Opcode::I64Load32U}, {""}, {""}, {""}, -#line 296 "src/lexer-keywords.txt" +#line 294 "src/lexer-keywords.txt" {"i64.atomic.load", TokenType::AtomicLoad, Opcode::I64AtomicLoad}, -#line 190 "src/lexer-keywords.txt" +#line 188 "src/lexer-keywords.txt" {"i32.atomic.load", TokenType::AtomicLoad, Opcode::I32AtomicLoad}, {""}, {""}, {""}, {""}, {""}, {""}, #line 457 "src/lexer-keywords.txt" {"return_call", TokenType::ReturnCall, Opcode::ReturnCall}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 435 "src/lexer-keywords.txt" +#line 433 "src/lexer-keywords.txt" {"loop", TokenType::Loop, Opcode::Loop}, {""}, -#line 152 "src/lexer-keywords.txt" +#line 150 "src/lexer-keywords.txt" {"get", TokenType::Get}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, #line 21 "src/lexer-keywords.txt" {"assert_malformed", TokenType::AssertMalformed}, -#line 127 "src/lexer-keywords.txt" +#line 125 "src/lexer-keywords.txt" {"f64.trunc", TokenType::Unary, Opcode::F64Trunc}, -#line 76 "src/lexer-keywords.txt" +#line 74 "src/lexer-keywords.txt" {"f32.trunc", TokenType::Unary, Opcode::F32Trunc}, {""}, {""}, {""}, -#line 41 "src/lexer-keywords.txt" +#line 39 "src/lexer-keywords.txt" {"drop", TokenType::Drop, Opcode::Drop}, {""}, {""}, {""}, -#line 332 "src/lexer-keywords.txt" +#line 330 "src/lexer-keywords.txt" {"i64.ctz", TokenType::Unary, Opcode::I64Ctz}, -#line 218 "src/lexer-keywords.txt" +#line 216 "src/lexer-keywords.txt" {"i32.ctz", TokenType::Unary, Opcode::I32Ctz}, - {""}, {""}, + {""}, +#line 443 "src/lexer-keywords.txt" + {"nan:canonical", TokenType::NanCanonical}, #line 447 "src/lexer-keywords.txt" {"param", TokenType::Param}, #line 475 "src/lexer-keywords.txt" {"v128.and", TokenType::Binary, Opcode::V128And}, {""}, -#line 31 "src/lexer-keywords.txt" +#line 29 "src/lexer-keywords.txt" {"br_if", TokenType::BrIf, Opcode::BrIf}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 130 "src/lexer-keywords.txt" +#line 128 "src/lexer-keywords.txt" {"f64x2.add", TokenType::Binary, Opcode::F64X2Add}, #line 481 "src/lexer-keywords.txt" {"v128.store", TokenType::Store, Opcode::V128Store}, -#line 35 "src/lexer-keywords.txt" +#line 33 "src/lexer-keywords.txt" {"call_indirect", TokenType::CallIndirect, Opcode::CallIndirect}, -#line 383 "src/lexer-keywords.txt" +#line 381 "src/lexer-keywords.txt" {"i64x2.add", TokenType::Binary, Opcode::I64X2Add}, {""}, -#line 315 "src/lexer-keywords.txt" +#line 313 "src/lexer-keywords.txt" {"i64.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8SubU}, -#line 202 "src/lexer-keywords.txt" +#line 200 "src/lexer-keywords.txt" {"i32.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8SubU}, {""}, -#line 330 "src/lexer-keywords.txt" +#line 328 "src/lexer-keywords.txt" {"i64.clz", TokenType::Unary, Opcode::I64Clz}, -#line 216 "src/lexer-keywords.txt" +#line 214 "src/lexer-keywords.txt" {"i32.clz", TokenType::Unary, Opcode::I32Clz}, {""}, -#line 133 "src/lexer-keywords.txt" +#line 131 "src/lexer-keywords.txt" {"f64x2.div", TokenType::Binary, Opcode::F64X2Div}, -#line 103 "src/lexer-keywords.txt" +#line 101 "src/lexer-keywords.txt" {"f64.convert_i32_s", TokenType::Convert, Opcode::F64ConvertI32S}, -#line 52 "src/lexer-keywords.txt" +#line 50 "src/lexer-keywords.txt" {"f32.convert_i32_s", TokenType::Convert, Opcode::F32ConvertI32S}, {""}, #line 477 "src/lexer-keywords.txt" {"v128.const", TokenType::Const, Opcode::V128Const}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 105 "src/lexer-keywords.txt" +#line 103 "src/lexer-keywords.txt" {"f64.convert_i64_s", TokenType::Convert, Opcode::F64ConvertI64S}, -#line 54 "src/lexer-keywords.txt" +#line 52 "src/lexer-keywords.txt" {"f32.convert_i64_s", TokenType::Convert, Opcode::F32ConvertI64S}, -#line 23 "src/lexer-keywords.txt" - {"assert_return_canonical_nan", TokenType::AssertReturnCanonicalNan}, -#line 374 "src/lexer-keywords.txt" + {""}, +#line 372 "src/lexer-keywords.txt" {"i64.trunc_f32_s", TokenType::Convert, Opcode::I64TruncF32S}, -#line 254 "src/lexer-keywords.txt" +#line 252 "src/lexer-keywords.txt" {"i32.trunc_f32_s", TokenType::Convert, Opcode::I32TruncF32S}, -#line 375 "src/lexer-keywords.txt" +#line 373 "src/lexer-keywords.txt" {"i64.trunc_f32_u", TokenType::Convert, Opcode::I64TruncF32U}, -#line 255 "src/lexer-keywords.txt" +#line 253 "src/lexer-keywords.txt" {"i32.trunc_f32_u", TokenType::Convert, Opcode::I32TruncF32U}, -#line 384 "src/lexer-keywords.txt" +#line 382 "src/lexer-keywords.txt" {"i64x2.all_true", TokenType::Unary, Opcode::I64X2AllTrue}, #line 492 "src/lexer-keywords.txt" {"f32.demote/f64", TokenType::Convert, Opcode::F32DemoteF64}, {""}, {""}, {""}, {""}, -#line 321 "src/lexer-keywords.txt" +#line 319 "src/lexer-keywords.txt" {"i64.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I64AtomicRmwOr}, -#line 208 "src/lexer-keywords.txt" +#line 206 "src/lexer-keywords.txt" {"i32.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I32AtomicRmwOr}, -#line 322 "src/lexer-keywords.txt" +#line 320 "src/lexer-keywords.txt" {"i64.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I64AtomicRmwSub}, -#line 209 "src/lexer-keywords.txt" +#line 207 "src/lexer-keywords.txt" {"i32.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I32AtomicRmwSub}, -#line 376 "src/lexer-keywords.txt" +#line 374 "src/lexer-keywords.txt" {"i64.trunc_f64_s", TokenType::Convert, Opcode::I64TruncF64S}, -#line 256 "src/lexer-keywords.txt" +#line 254 "src/lexer-keywords.txt" {"i32.trunc_f64_s", TokenType::Convert, Opcode::I32TruncF64S}, -#line 377 "src/lexer-keywords.txt" +#line 375 "src/lexer-keywords.txt" {"i64.trunc_f64_u", TokenType::Convert, Opcode::I64TruncF64U}, -#line 257 "src/lexer-keywords.txt" +#line 255 "src/lexer-keywords.txt" {"i32.trunc_f64_u", TokenType::Convert, Opcode::I32TruncF64U}, #line 478 "src/lexer-keywords.txt" {"v128.load", TokenType::Load, Opcode::V128Load}, -#line 312 "src/lexer-keywords.txt" +#line 310 "src/lexer-keywords.txt" {"i64.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AndU}, -#line 199 "src/lexer-keywords.txt" +#line 197 "src/lexer-keywords.txt" {"i32.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AndU}, #line 463 "src/lexer-keywords.txt" {"table.get", TokenType::TableGet, Opcode::TableGet}, #line 480 "src/lexer-keywords.txt" {"v128.or", TokenType::Binary, Opcode::V128Or}, -#line 318 "src/lexer-keywords.txt" +#line 316 "src/lexer-keywords.txt" {"i64.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I64AtomicRmwAdd}, -#line 205 "src/lexer-keywords.txt" +#line 203 "src/lexer-keywords.txt" {"i32.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I32AtomicRmwAdd}, -#line 348 "src/lexer-keywords.txt" +#line 346 "src/lexer-keywords.txt" {"i64.load16_s", TokenType::Load, Opcode::I64Load16S}, -#line 231 "src/lexer-keywords.txt" +#line 229 "src/lexer-keywords.txt" {"i32.load16_s", TokenType::Load, Opcode::I32Load16S}, {""}, {""}, -#line 349 "src/lexer-keywords.txt" +#line 347 "src/lexer-keywords.txt" {"i64.load16_u", TokenType::Load, Opcode::I64Load16U}, -#line 232 "src/lexer-keywords.txt" +#line 230 "src/lexer-keywords.txt" {"i32.load16_u", TokenType::Load, Opcode::I32Load16U}, {""}, {""}, {""}, {""}, #line 476 "src/lexer-keywords.txt" {"v128.bitselect", TokenType::Ternary, Opcode::V128BitSelect}, {""}, -#line 359 "src/lexer-keywords.txt" +#line 357 "src/lexer-keywords.txt" {"i64.or", TokenType::Binary, Opcode::I64Or}, -#line 240 "src/lexer-keywords.txt" +#line 238 "src/lexer-keywords.txt" {"i32.or", TokenType::Binary, Opcode::I32Or}, -#line 104 "src/lexer-keywords.txt" +#line 102 "src/lexer-keywords.txt" {"f64.convert_i32_u", TokenType::Convert, Opcode::F64ConvertI32U}, -#line 53 "src/lexer-keywords.txt" +#line 51 "src/lexer-keywords.txt" {"f32.convert_i32_u", TokenType::Convert, Opcode::F32ConvertI32U}, {""}, -#line 98 "src/lexer-keywords.txt" +#line 96 "src/lexer-keywords.txt" {"f32x4", TokenType::F32X4}, {""}, {""}, -#line 287 "src/lexer-keywords.txt" +#line 285 "src/lexer-keywords.txt" {"i32x4", TokenType::I32X4}, -#line 155 "src/lexer-keywords.txt" +#line 153 "src/lexer-keywords.txt" {"global", TokenType::Global}, -#line 319 "src/lexer-keywords.txt" +#line 317 "src/lexer-keywords.txt" {"i64.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I64AtomicRmwAnd}, -#line 206 "src/lexer-keywords.txt" +#line 204 "src/lexer-keywords.txt" {"i32.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I32AtomicRmwAnd}, -#line 308 "src/lexer-keywords.txt" +#line 306 "src/lexer-keywords.txt" {"i64.atomic.rmw32.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32SubU}, {""}, #line 18 "src/lexer-keywords.txt" @@ -638,90 +639,90 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 456 "src/lexer-keywords.txt" {"return_call_indirect", TokenType::ReturnCallIndirect, Opcode::ReturnCallIndirect}, {""}, -#line 106 "src/lexer-keywords.txt" +#line 104 "src/lexer-keywords.txt" {"f64.convert_i64_u", TokenType::Convert, Opcode::F64ConvertI64U}, -#line 55 "src/lexer-keywords.txt" +#line 53 "src/lexer-keywords.txt" {"f32.convert_i64_u", TokenType::Convert, Opcode::F32ConvertI64U}, {""}, {""}, -#line 369 "src/lexer-keywords.txt" +#line 367 "src/lexer-keywords.txt" {"i64.store16", TokenType::Store, Opcode::I64Store16}, -#line 250 "src/lexer-keywords.txt" +#line 248 "src/lexer-keywords.txt" {"i32.store16", TokenType::Store, Opcode::I32Store16}, {""}, -#line 311 "src/lexer-keywords.txt" +#line 309 "src/lexer-keywords.txt" {"i64.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AddU}, -#line 198 "src/lexer-keywords.txt" +#line 196 "src/lexer-keywords.txt" {"i32.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AddU}, -#line 305 "src/lexer-keywords.txt" +#line 303 "src/lexer-keywords.txt" {"i64.atomic.rmw32.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AndU}, {""}, {""}, {""}, {""}, {""}, -#line 112 "src/lexer-keywords.txt" +#line 110 "src/lexer-keywords.txt" {"f64.gt", TokenType::Compare, Opcode::F64Gt}, -#line 62 "src/lexer-keywords.txt" +#line 60 "src/lexer-keywords.txt" {"f32.gt", TokenType::Compare, Opcode::F32Gt}, {""}, {""}, {""}, {""}, {""}, -#line 154 "src/lexer-keywords.txt" +#line 152 "src/lexer-keywords.txt" {"global.set", TokenType::GlobalSet, Opcode::GlobalSet}, {""}, {""}, {""}, -#line 146 "src/lexer-keywords.txt" +#line 144 "src/lexer-keywords.txt" {"f64x2.splat", TokenType::Unary, Opcode::F64X2Splat}, -#line 111 "src/lexer-keywords.txt" +#line 109 "src/lexer-keywords.txt" {"f64.ge", TokenType::Compare, Opcode::F64Ge}, -#line 61 "src/lexer-keywords.txt" +#line 59 "src/lexer-keywords.txt" {"f32.ge", TokenType::Compare, Opcode::F32Ge}, -#line 393 "src/lexer-keywords.txt" +#line 391 "src/lexer-keywords.txt" {"i64x2.splat", TokenType::Unary, Opcode::I64X2Splat}, {""}, {""}, -#line 344 "src/lexer-keywords.txt" +#line 342 "src/lexer-keywords.txt" {"i64.gt_s", TokenType::Compare, Opcode::I64GtS}, -#line 227 "src/lexer-keywords.txt" +#line 225 "src/lexer-keywords.txt" {"i32.gt_s", TokenType::Compare, Opcode::I32GtS}, {""}, {""}, -#line 345 "src/lexer-keywords.txt" +#line 343 "src/lexer-keywords.txt" {"i64.gt_u", TokenType::Compare, Opcode::I64GtU}, -#line 228 "src/lexer-keywords.txt" +#line 226 "src/lexer-keywords.txt" {"i32.gt_u", TokenType::Compare, Opcode::I32GtU}, -#line 342 "src/lexer-keywords.txt" +#line 340 "src/lexer-keywords.txt" {"i64.ge_s", TokenType::Compare, Opcode::I64GeS}, -#line 225 "src/lexer-keywords.txt" +#line 223 "src/lexer-keywords.txt" {"i32.ge_s", TokenType::Compare, Opcode::I32GeS}, {""}, {""}, -#line 343 "src/lexer-keywords.txt" +#line 341 "src/lexer-keywords.txt" {"i64.ge_u", TokenType::Compare, Opcode::I64GeU}, -#line 226 "src/lexer-keywords.txt" +#line 224 "src/lexer-keywords.txt" {"i32.ge_u", TokenType::Compare, Opcode::I32GeU}, -#line 137 "src/lexer-keywords.txt" +#line 135 "src/lexer-keywords.txt" {"f64x2.gt", TokenType::Compare, Opcode::F64X2Gt}, -#line 439 "src/lexer-keywords.txt" +#line 437 "src/lexer-keywords.txt" {"memory.init", TokenType::MemoryInit, Opcode::MemoryInit}, {""}, #line 444 "src/lexer-keywords.txt" {"nop", TokenType::Nop, Opcode::Nop}, {""}, -#line 93 "src/lexer-keywords.txt" +#line 91 "src/lexer-keywords.txt" {"f32x4.ne", TokenType::Compare, Opcode::F32X4Ne}, -#line 90 "src/lexer-keywords.txt" +#line 88 "src/lexer-keywords.txt" {"f32x4.min", TokenType::Binary, Opcode::F32X4Min}, -#line 304 "src/lexer-keywords.txt" +#line 302 "src/lexer-keywords.txt" {"i64.atomic.rmw32.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AddU}, -#line 280 "src/lexer-keywords.txt" +#line 278 "src/lexer-keywords.txt" {"i32x4.ne", TokenType::Compare, Opcode::I32X4Ne}, {""}, {""}, -#line 440 "src/lexer-keywords.txt" +#line 438 "src/lexer-keywords.txt" {"memory.size", TokenType::MemorySize, Opcode::MemorySize}, -#line 136 "src/lexer-keywords.txt" +#line 134 "src/lexer-keywords.txt" {"f64x2.ge", TokenType::Compare, Opcode::F64X2Ge}, -#line 325 "src/lexer-keywords.txt" +#line 323 "src/lexer-keywords.txt" {"i64.atomic.store16", TokenType::AtomicStore, Opcode::I64AtomicStore16}, -#line 212 "src/lexer-keywords.txt" +#line 210 "src/lexer-keywords.txt" {"i32.atomic.store16", TokenType::AtomicStore, Opcode::I32AtomicStore16}, -#line 88 "src/lexer-keywords.txt" +#line 86 "src/lexer-keywords.txt" {"f32x4.lt", TokenType::Compare, Opcode::F32X4Lt}, {""}, -#line 431 "src/lexer-keywords.txt" +#line 429 "src/lexer-keywords.txt" {"local.get", TokenType::LocalGet, Opcode::LocalGet}, {""}, {""}, -#line 25 "src/lexer-keywords.txt" +#line 23 "src/lexer-keywords.txt" {"assert_return_func", TokenType::AssertReturnFunc}, #line 515 "src/lexer-keywords.txt" {"i64.trunc_s/f32", TokenType::Convert, Opcode::I64TruncF32S}, @@ -731,24 +732,24 @@ Perfect_Hash::InWordSet (const char *str, size_t len) {"i64.trunc_u/f32", TokenType::Convert, Opcode::I64TruncF32U}, #line 507 "src/lexer-keywords.txt" {"i32.trunc_u/f32", TokenType::Convert, Opcode::I32TruncF32U}, -#line 294 "src/lexer-keywords.txt" +#line 292 "src/lexer-keywords.txt" {"i64.atomic.load32_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad32U}, -#line 276 "src/lexer-keywords.txt" +#line 274 "src/lexer-keywords.txt" {"i32x4.lt_s", TokenType::Compare, Opcode::I32X4LtS}, -#line 87 "src/lexer-keywords.txt" +#line 85 "src/lexer-keywords.txt" {"f32x4.le", TokenType::Compare, Opcode::F32X4Le}, -#line 277 "src/lexer-keywords.txt" +#line 275 "src/lexer-keywords.txt" {"i32x4.lt_u", TokenType::Compare, Opcode::I32X4LtU}, -#line 366 "src/lexer-keywords.txt" +#line 364 "src/lexer-keywords.txt" {"i64.shl", TokenType::Binary, Opcode::I64Shl}, -#line 247 "src/lexer-keywords.txt" +#line 245 "src/lexer-keywords.txt" {"i32.shl", TokenType::Binary, Opcode::I32Shl}, {""}, -#line 273 "src/lexer-keywords.txt" +#line 271 "src/lexer-keywords.txt" {"i32x4.le_s", TokenType::Compare, Opcode::I32X4LeS}, -#line 78 "src/lexer-keywords.txt" +#line 76 "src/lexer-keywords.txt" {"f32x4.abs", TokenType::Unary, Opcode::F32X4Abs}, -#line 274 "src/lexer-keywords.txt" +#line 272 "src/lexer-keywords.txt" {"i32x4.le_u", TokenType::Compare, Opcode::I32X4LeU}, #line 516 "src/lexer-keywords.txt" {"i64.trunc_s/f64", TokenType::Convert, Opcode::I64TruncF64S}, @@ -762,58 +763,58 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 464 "src/lexer-keywords.txt" {"table.grow", TokenType::TableGrow, Opcode::TableGrow}, {""}, -#line 97 "src/lexer-keywords.txt" +#line 95 "src/lexer-keywords.txt" {"f32x4.sub", TokenType::Binary, Opcode::F32X4Sub}, {""}, -#line 306 "src/lexer-keywords.txt" +#line 304 "src/lexer-keywords.txt" {"i64.atomic.rmw32.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw32CmpxchgU}, -#line 286 "src/lexer-keywords.txt" +#line 284 "src/lexer-keywords.txt" {"i32x4.sub", TokenType::Binary, Opcode::I32X4Sub}, #line 482 "src/lexer-keywords.txt" {"v128", Type::V128}, -#line 437 "src/lexer-keywords.txt" +#line 435 "src/lexer-keywords.txt" {"memory.fill", TokenType::MemoryFill, Opcode::MemoryFill}, {""}, -#line 91 "src/lexer-keywords.txt" +#line 89 "src/lexer-keywords.txt" {"f32x4.mul", TokenType::Binary, Opcode::F32X4Mul}, -#line 307 "src/lexer-keywords.txt" +#line 305 "src/lexer-keywords.txt" {"i64.atomic.rmw32.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32OrU}, #line 448 "src/lexer-keywords.txt" {"quote", TokenType::Quote}, -#line 278 "src/lexer-keywords.txt" +#line 276 "src/lexer-keywords.txt" {"i32x4.mul", TokenType::Binary, Opcode::I32X4Mul}, #line 501 "src/lexer-keywords.txt" {"get_local", TokenType::LocalGet, Opcode::LocalGet}, -#line 378 "src/lexer-keywords.txt" +#line 376 "src/lexer-keywords.txt" {"i64.trunc_sat_f32_s", TokenType::Convert, Opcode::I64TruncSatF32S}, -#line 258 "src/lexer-keywords.txt" +#line 256 "src/lexer-keywords.txt" {"i32.trunc_sat_f32_s", TokenType::Convert, Opcode::I32TruncSatF32S}, {""}, -#line 37 "src/lexer-keywords.txt" +#line 35 "src/lexer-keywords.txt" {"catch", TokenType::Catch, Opcode::Catch}, -#line 379 "src/lexer-keywords.txt" +#line 377 "src/lexer-keywords.txt" {"i64.trunc_sat_f32_u", TokenType::Convert, Opcode::I64TruncSatF32U}, -#line 259 "src/lexer-keywords.txt" +#line 257 "src/lexer-keywords.txt" {"i32.trunc_sat_f32_u", TokenType::Convert, Opcode::I32TruncSatF32U}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 367 "src/lexer-keywords.txt" +#line 365 "src/lexer-keywords.txt" {"i64.shr_s", TokenType::Binary, Opcode::I64ShrS}, -#line 248 "src/lexer-keywords.txt" +#line 246 "src/lexer-keywords.txt" {"i32.shr_s", TokenType::Binary, Opcode::I32ShrS}, {""}, {""}, -#line 368 "src/lexer-keywords.txt" +#line 366 "src/lexer-keywords.txt" {"i64.shr_u", TokenType::Binary, Opcode::I64ShrU}, -#line 249 "src/lexer-keywords.txt" +#line 247 "src/lexer-keywords.txt" {"i32.shr_u", TokenType::Binary, Opcode::I32ShrU}, {""}, {""}, {""}, -#line 301 "src/lexer-keywords.txt" +#line 299 "src/lexer-keywords.txt" {"i64.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16SubU}, -#line 195 "src/lexer-keywords.txt" +#line 193 "src/lexer-keywords.txt" {"i32.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16SubU}, {""}, {""}, {""}, -#line 32 "src/lexer-keywords.txt" +#line 30 "src/lexer-keywords.txt" {"br_on_exn", TokenType::BrOnExn, Opcode::BrOnExn}, -#line 387 "src/lexer-keywords.txt" +#line 385 "src/lexer-keywords.txt" {"i64x2.load_splat", TokenType::Load, Opcode::I64X2LoadSplat}, {""}, #line 471 "src/lexer-keywords.txt" @@ -821,22 +822,22 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 453 "src/lexer-keywords.txt" {"register", TokenType::Register}, {""}, {""}, {""}, {""}, -#line 298 "src/lexer-keywords.txt" +#line 296 "src/lexer-keywords.txt" {"i64.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AndU}, -#line 192 "src/lexer-keywords.txt" +#line 190 "src/lexer-keywords.txt" {"i32.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AndU}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 110 "src/lexer-keywords.txt" +#line 108 "src/lexer-keywords.txt" {"f64.floor", TokenType::Unary, Opcode::F64Floor}, -#line 60 "src/lexer-keywords.txt" +#line 58 "src/lexer-keywords.txt" {"f32.floor", TokenType::Unary, Opcode::F32Floor}, {""}, {""}, {""}, {""}, {""}, {""}, #line 523 "src/lexer-keywords.txt" {"set_global", TokenType::GlobalSet, Opcode::GlobalSet}, {""}, -#line 124 "src/lexer-keywords.txt" +#line 122 "src/lexer-keywords.txt" {"f64.sqrt", TokenType::Unary, Opcode::F64Sqrt}, -#line 73 "src/lexer-keywords.txt" +#line 71 "src/lexer-keywords.txt" {"f32.sqrt", TokenType::Unary, Opcode::F32Sqrt}, {""}, {""}, #line 494 "src/lexer-keywords.txt" @@ -851,99 +852,99 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 449 "src/lexer-keywords.txt" {"ref.func", TokenType::RefFunc, Opcode::RefFunc}, {""}, {""}, {""}, -#line 398 "src/lexer-keywords.txt" +#line 396 "src/lexer-keywords.txt" {"i64.xor", TokenType::Binary, Opcode::I64Xor}, -#line 290 "src/lexer-keywords.txt" +#line 288 "src/lexer-keywords.txt" {"i32.xor", TokenType::Binary, Opcode::I32Xor}, -#line 352 "src/lexer-keywords.txt" +#line 350 "src/lexer-keywords.txt" {"i64.load8_s", TokenType::Load, Opcode::I64Load8S}, -#line 233 "src/lexer-keywords.txt" +#line 231 "src/lexer-keywords.txt" {"i32.load8_s", TokenType::Load, Opcode::I32Load8S}, -#line 313 "src/lexer-keywords.txt" +#line 311 "src/lexer-keywords.txt" {"i64.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw8CmpxchgU}, -#line 200 "src/lexer-keywords.txt" +#line 198 "src/lexer-keywords.txt" {"i32.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw8CmpxchgU}, -#line 353 "src/lexer-keywords.txt" +#line 351 "src/lexer-keywords.txt" {"i64.load8_u", TokenType::Load, Opcode::I64Load8U}, -#line 234 "src/lexer-keywords.txt" +#line 232 "src/lexer-keywords.txt" {"i32.load8_u", TokenType::Load, Opcode::I32Load8U}, -#line 26 "src/lexer-keywords.txt" +#line 24 "src/lexer-keywords.txt" {"assert_trap", TokenType::AssertTrap}, -#line 297 "src/lexer-keywords.txt" +#line 295 "src/lexer-keywords.txt" {"i64.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AddU}, -#line 191 "src/lexer-keywords.txt" +#line 189 "src/lexer-keywords.txt" {"i32.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AddU}, {""}, {""}, {""}, -#line 371 "src/lexer-keywords.txt" +#line 369 "src/lexer-keywords.txt" {"i64.store8", TokenType::Store, Opcode::I64Store8}, -#line 251 "src/lexer-keywords.txt" +#line 249 "src/lexer-keywords.txt" {"i32.store8", TokenType::Store, Opcode::I32Store8}, {""}, {""}, {""}, -#line 293 "src/lexer-keywords.txt" +#line 291 "src/lexer-keywords.txt" {"i64.atomic.load16_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad16U}, -#line 188 "src/lexer-keywords.txt" +#line 186 "src/lexer-keywords.txt" {"i32.atomic.load16_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad16U}, -#line 79 "src/lexer-keywords.txt" +#line 77 "src/lexer-keywords.txt" {"f32x4.add", TokenType::Binary, Opcode::F32X4Add}, {""}, {""}, -#line 264 "src/lexer-keywords.txt" +#line 262 "src/lexer-keywords.txt" {"i32x4.add", TokenType::Binary, Opcode::I32X4Add}, {""}, -#line 314 "src/lexer-keywords.txt" +#line 312 "src/lexer-keywords.txt" {"i64.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8OrU}, -#line 201 "src/lexer-keywords.txt" +#line 199 "src/lexer-keywords.txt" {"i32.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8OrU}, {""}, {""}, {""}, {""}, -#line 82 "src/lexer-keywords.txt" +#line 80 "src/lexer-keywords.txt" {"f32x4.div", TokenType::Binary, Opcode::F32X4Div}, {""}, {""}, {""}, {""}, {""}, {""}, #line 19 "src/lexer-keywords.txt" {"assert_exhaustion", TokenType::AssertExhaustion}, {""}, -#line 418 "src/lexer-keywords.txt" +#line 416 "src/lexer-keywords.txt" {"i8x16.ne", TokenType::Compare, Opcode::I8X16Ne}, {""}, {""}, -#line 72 "src/lexer-keywords.txt" +#line 70 "src/lexer-keywords.txt" {"f32.reinterpret_i32", TokenType::Convert, Opcode::F32ReinterpretI32}, {""}, -#line 299 "src/lexer-keywords.txt" +#line 297 "src/lexer-keywords.txt" {"i64.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw16CmpxchgU}, -#line 193 "src/lexer-keywords.txt" +#line 191 "src/lexer-keywords.txt" {"i32.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw16CmpxchgU}, {""}, -#line 338 "src/lexer-keywords.txt" +#line 336 "src/lexer-keywords.txt" {"i64.extend32_s", TokenType::Unary, Opcode::I64Extend32S}, -#line 120 "src/lexer-keywords.txt" +#line 118 "src/lexer-keywords.txt" {"f64.neg", TokenType::Unary, Opcode::F64Neg}, -#line 70 "src/lexer-keywords.txt" +#line 68 "src/lexer-keywords.txt" {"f32.neg", TokenType::Unary, Opcode::F32Neg}, -#line 300 "src/lexer-keywords.txt" +#line 298 "src/lexer-keywords.txt" {"i64.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16OrU}, -#line 194 "src/lexer-keywords.txt" +#line 192 "src/lexer-keywords.txt" {"i32.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16OrU}, {""}, -#line 265 "src/lexer-keywords.txt" +#line 263 "src/lexer-keywords.txt" {"i32x4.all_true", TokenType::Unary, Opcode::I32X4AllTrue}, -#line 123 "src/lexer-keywords.txt" +#line 121 "src/lexer-keywords.txt" {"f64.reinterpret_i64", TokenType::Convert, Opcode::F64ReinterpretI64}, -#line 390 "src/lexer-keywords.txt" +#line 388 "src/lexer-keywords.txt" {"i64x2.shl", TokenType::Binary, Opcode::I64X2Shl}, {""}, -#line 414 "src/lexer-keywords.txt" +#line 412 "src/lexer-keywords.txt" {"i8x16.lt_s", TokenType::Compare, Opcode::I8X16LtS}, -#line 340 "src/lexer-keywords.txt" +#line 338 "src/lexer-keywords.txt" {"i64.extend_i32_s", TokenType::Convert, Opcode::I64ExtendI32S}, -#line 415 "src/lexer-keywords.txt" +#line 413 "src/lexer-keywords.txt" {"i8x16.lt_u", TokenType::Compare, Opcode::I8X16LtU}, {""}, {""}, -#line 341 "src/lexer-keywords.txt" +#line 339 "src/lexer-keywords.txt" {"i64.extend_i32_u", TokenType::Convert, Opcode::I64ExtendI32U}, -#line 411 "src/lexer-keywords.txt" +#line 409 "src/lexer-keywords.txt" {"i8x16.le_s", TokenType::Compare, Opcode::I8X16LeS}, {""}, -#line 412 "src/lexer-keywords.txt" +#line 410 "src/lexer-keywords.txt" {"i8x16.le_u", TokenType::Compare, Opcode::I8X16LeU}, -#line 176 "src/lexer-keywords.txt" +#line 174 "src/lexer-keywords.txt" {"i16x8.ne", TokenType::Compare, Opcode::I16X8Ne}, #line 512 "src/lexer-keywords.txt" {"i64.extend_s/i32", TokenType::Convert, Opcode::I64ExtendI32S}, @@ -954,157 +955,157 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 487 "src/lexer-keywords.txt" {"anyfunc", Type::Funcref}, {""}, {""}, {""}, -#line 426 "src/lexer-keywords.txt" +#line 424 "src/lexer-keywords.txt" {"i8x16.sub", TokenType::Binary, Opcode::I8X16Sub}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 416 "src/lexer-keywords.txt" +#line 414 "src/lexer-keywords.txt" {"i8x16.mul", TokenType::Binary, Opcode::I8X16Mul}, -#line 172 "src/lexer-keywords.txt" +#line 170 "src/lexer-keywords.txt" {"i16x8.lt_s", TokenType::Compare, Opcode::I16X8LtS}, {""}, -#line 173 "src/lexer-keywords.txt" +#line 171 "src/lexer-keywords.txt" {"i16x8.lt_u", TokenType::Compare, Opcode::I16X8LtU}, -#line 391 "src/lexer-keywords.txt" +#line 389 "src/lexer-keywords.txt" {"i64x2.shr_s", TokenType::Binary, Opcode::I64X2ShrS}, {""}, {""}, -#line 169 "src/lexer-keywords.txt" +#line 167 "src/lexer-keywords.txt" {"i16x8.le_s", TokenType::Compare, Opcode::I16X8LeS}, -#line 392 "src/lexer-keywords.txt" +#line 390 "src/lexer-keywords.txt" {"i64x2.shr_u", TokenType::Binary, Opcode::I64X2ShrU}, -#line 170 "src/lexer-keywords.txt" +#line 168 "src/lexer-keywords.txt" {"i16x8.le_u", TokenType::Compare, Opcode::I16X8LeU}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 184 "src/lexer-keywords.txt" +#line 182 "src/lexer-keywords.txt" {"i16x8.sub", TokenType::Binary, Opcode::I16X8Sub}, -#line 427 "src/lexer-keywords.txt" +#line 425 "src/lexer-keywords.txt" {"i8x16", TokenType::I8X16}, {""}, -#line 385 "src/lexer-keywords.txt" +#line 383 "src/lexer-keywords.txt" {"i64x2.any_true", TokenType::Unary, Opcode::I64X2AnyTrue}, #line 474 "src/lexer-keywords.txt" {"unreachable", TokenType::Unreachable, Opcode::Unreachable}, -#line 295 "src/lexer-keywords.txt" +#line 293 "src/lexer-keywords.txt" {"i64.atomic.load8_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad8U}, -#line 189 "src/lexer-keywords.txt" +#line 187 "src/lexer-keywords.txt" {"i32.atomic.load8_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad8U}, -#line 174 "src/lexer-keywords.txt" +#line 172 "src/lexer-keywords.txt" {"i16x8.mul", TokenType::Binary, Opcode::I16X8Mul}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 145 "src/lexer-keywords.txt" +#line 143 "src/lexer-keywords.txt" {"f64x2.replace_lane", TokenType::SimdLaneOp, Opcode::F64X2ReplaceLane}, {""}, {""}, -#line 389 "src/lexer-keywords.txt" +#line 387 "src/lexer-keywords.txt" {"i64x2.replace_lane", TokenType::SimdLaneOp, Opcode::I64X2ReplaceLane}, {""}, {""}, {""}, {""}, -#line 147 "src/lexer-keywords.txt" +#line 145 "src/lexer-keywords.txt" {"f64x2.sqrt", TokenType::Unary, Opcode::F64X2Sqrt}, -#line 95 "src/lexer-keywords.txt" +#line 93 "src/lexer-keywords.txt" {"f32x4.splat", TokenType::Unary, Opcode::F32X4Splat}, {""}, {""}, -#line 285 "src/lexer-keywords.txt" +#line 283 "src/lexer-keywords.txt" {"i32x4.splat", TokenType::Unary, Opcode::I32X4Splat}, {""}, -#line 153 "src/lexer-keywords.txt" +#line 151 "src/lexer-keywords.txt" {"global.get", TokenType::GlobalGet, Opcode::GlobalGet}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 336 "src/lexer-keywords.txt" +#line 334 "src/lexer-keywords.txt" {"i64.eqz", TokenType::Convert, Opcode::I64Eqz}, -#line 222 "src/lexer-keywords.txt" +#line 220 "src/lexer-keywords.txt" {"i32.eqz", TokenType::Convert, Opcode::I32Eqz}, {""}, {""}, {""}, {""}, -#line 86 "src/lexer-keywords.txt" +#line 84 "src/lexer-keywords.txt" {"f32x4.gt", TokenType::Compare, Opcode::F32X4Gt}, {""}, {""}, {""}, {""}, -#line 424 "src/lexer-keywords.txt" +#line 422 "src/lexer-keywords.txt" {"i8x16.sub_saturate_s", TokenType::Binary, Opcode::I8X16SubSaturateS}, {""}, -#line 425 "src/lexer-keywords.txt" +#line 423 "src/lexer-keywords.txt" {"i8x16.sub_saturate_u", TokenType::Binary, Opcode::I8X16SubSaturateU}, {""}, {""}, {""}, -#line 271 "src/lexer-keywords.txt" +#line 269 "src/lexer-keywords.txt" {"i32x4.gt_s", TokenType::Compare, Opcode::I32X4GtS}, -#line 85 "src/lexer-keywords.txt" +#line 83 "src/lexer-keywords.txt" {"f32x4.ge", TokenType::Compare, Opcode::F32X4Ge}, -#line 272 "src/lexer-keywords.txt" +#line 270 "src/lexer-keywords.txt" {"i32x4.gt_u", TokenType::Compare, Opcode::I32X4GtU}, #line 493 "src/lexer-keywords.txt" {"f32.reinterpret/i32", TokenType::Convert, Opcode::F32ReinterpretI32}, {""}, {""}, -#line 269 "src/lexer-keywords.txt" +#line 267 "src/lexer-keywords.txt" {"i32x4.ge_s", TokenType::Compare, Opcode::I32X4GeS}, {""}, -#line 270 "src/lexer-keywords.txt" +#line 268 "src/lexer-keywords.txt" {"i32x4.ge_u", TokenType::Compare, Opcode::I32X4GeU}, {""}, {""}, {""}, #line 472 "src/lexer-keywords.txt" {"try", TokenType::Try, Opcode::Try}, -#line 143 "src/lexer-keywords.txt" +#line 141 "src/lexer-keywords.txt" {"f64x2.neg", TokenType::Unary, Opcode::F64X2Neg}, {""}, #line 499 "src/lexer-keywords.txt" {"f64.reinterpret/i64", TokenType::Convert, Opcode::F64ReinterpretI64}, -#line 388 "src/lexer-keywords.txt" +#line 386 "src/lexer-keywords.txt" {"i64x2.neg", TokenType::Unary, Opcode::I64X2Neg}, {""}, {""}, {""}, -#line 401 "src/lexer-keywords.txt" +#line 399 "src/lexer-keywords.txt" {"i8x16.add", TokenType::Binary, Opcode::I8X16Add}, -#line 182 "src/lexer-keywords.txt" +#line 180 "src/lexer-keywords.txt" {"i16x8.sub_saturate_s", TokenType::Binary, Opcode::I16X8SubSaturateS}, {""}, -#line 183 "src/lexer-keywords.txt" +#line 181 "src/lexer-keywords.txt" {"i16x8.sub_saturate_u", TokenType::Binary, Opcode::I16X8SubSaturateU}, - {""}, {""}, {""}, {""}, {""}, -#line 441 "src/lexer-keywords.txt" + {""}, {""}, {""}, +#line 442 "src/lexer-keywords.txt" + {"nan:arithmetic", TokenType::NanArithmetic}, + {""}, +#line 439 "src/lexer-keywords.txt" {"memory", TokenType::Memory}, {""}, -#line 42 "src/lexer-keywords.txt" +#line 40 "src/lexer-keywords.txt" {"elem.drop", TokenType::ElemDrop, Opcode::ElemDrop}, - {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 22 "src/lexer-keywords.txt" - {"assert_return_arithmetic_nan", TokenType::AssertReturnArithmeticNan}, - {""}, -#line 122 "src/lexer-keywords.txt" + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 120 "src/lexer-keywords.txt" {"f64.promote_f32", TokenType::Convert, Opcode::F64PromoteF32}, {""}, {""}, -#line 317 "src/lexer-keywords.txt" +#line 315 "src/lexer-keywords.txt" {"i64.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XorU}, -#line 204 "src/lexer-keywords.txt" +#line 202 "src/lexer-keywords.txt" {"i32.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XorU}, {""}, -#line 159 "src/lexer-keywords.txt" +#line 157 "src/lexer-keywords.txt" {"i16x8.add", TokenType::Binary, Opcode::I16X8Add}, {""}, {""}, -#line 29 "src/lexer-keywords.txt" +#line 27 "src/lexer-keywords.txt" {"binary", TokenType::Bin}, -#line 402 "src/lexer-keywords.txt" +#line 400 "src/lexer-keywords.txt" {"i8x16.all_true", TokenType::Unary, Opcode::I8X16AllTrue}, {""}, {""}, {""}, {""}, {""}, -#line 380 "src/lexer-keywords.txt" +#line 378 "src/lexer-keywords.txt" {"i64.trunc_sat_f64_s", TokenType::Convert, Opcode::I64TruncSatF64S}, -#line 260 "src/lexer-keywords.txt" +#line 258 "src/lexer-keywords.txt" {"i32.trunc_sat_f64_s", TokenType::Convert, Opcode::I32TruncSatF64S}, {""}, {""}, -#line 381 "src/lexer-keywords.txt" +#line 379 "src/lexer-keywords.txt" {"i64.trunc_sat_f64_u", TokenType::Convert, Opcode::I64TruncSatF64U}, -#line 261 "src/lexer-keywords.txt" +#line 259 "src/lexer-keywords.txt" {"i32.trunc_sat_f64_u", TokenType::Convert, Opcode::I32TruncSatF64U}, -#line 39 "src/lexer-keywords.txt" +#line 37 "src/lexer-keywords.txt" {"data.drop", TokenType::DataDrop, Opcode::DataDrop}, {""}, {""}, {""}, {""}, {""}, #line 462 "src/lexer-keywords.txt" {"table.copy", TokenType::TableCopy, Opcode::TableCopy}, {""}, -#line 275 "src/lexer-keywords.txt" +#line 273 "src/lexer-keywords.txt" {"i32x4.load_splat", TokenType::Load, Opcode::I32X4LoadSplat}, {""}, -#line 399 "src/lexer-keywords.txt" +#line 397 "src/lexer-keywords.txt" {"i8x16.add_saturate_s", TokenType::Binary, Opcode::I8X16AddSaturateS}, {""}, -#line 400 "src/lexer-keywords.txt" +#line 398 "src/lexer-keywords.txt" {"i8x16.add_saturate_u", TokenType::Binary, Opcode::I8X16AddSaturateU}, {""}, {""}, -#line 160 "src/lexer-keywords.txt" +#line 158 "src/lexer-keywords.txt" {"i16x8.all_true", TokenType::Unary, Opcode::I16X8AllTrue}, #line 483 "src/lexer-keywords.txt" {"v128.xor", TokenType::Binary, Opcode::V128Xor}, @@ -1118,14 +1119,14 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 509 "src/lexer-keywords.txt" {"i32.trunc_u:sat/f32", TokenType::Convert, Opcode::I32TruncSatF32U}, {""}, {""}, {""}, {""}, -#line 135 "src/lexer-keywords.txt" +#line 133 "src/lexer-keywords.txt" {"f64x2.extract_lane", TokenType::SimdLaneOp, Opcode::F64X2ExtractLane}, {""}, -#line 396 "src/lexer-keywords.txt" +#line 394 "src/lexer-keywords.txt" {"i64x2.trunc_sat_f64x2_s", TokenType::Unary, Opcode::I64X2TruncSatF64X2S}, -#line 386 "src/lexer-keywords.txt" +#line 384 "src/lexer-keywords.txt" {"i64x2.extract_lane", TokenType::SimdLaneOp, Opcode::I64X2ExtractLane}, -#line 397 "src/lexer-keywords.txt" +#line 395 "src/lexer-keywords.txt" {"i64x2.trunc_sat_f64x2_u", TokenType::Unary, Opcode::I64X2TruncSatF64X2U}, #line 518 "src/lexer-keywords.txt" {"i64.trunc_s:sat/f64", TokenType::Convert, Opcode::I64TruncSatF64S}, @@ -1135,21 +1136,21 @@ Perfect_Hash::InWordSet (const char *str, size_t len) {"i64.trunc_u:sat/f64", TokenType::Convert, Opcode::I64TruncSatF64U}, #line 510 "src/lexer-keywords.txt" {"i32.trunc_u:sat/f64", TokenType::Convert, Opcode::I32TruncSatF64U}, -#line 157 "src/lexer-keywords.txt" +#line 155 "src/lexer-keywords.txt" {"i16x8.add_saturate_s", TokenType::Binary, Opcode::I16X8AddSaturateS}, {""}, -#line 158 "src/lexer-keywords.txt" +#line 156 "src/lexer-keywords.txt" {"i16x8.add_saturate_u", TokenType::Binary, Opcode::I16X8AddSaturateU}, {""}, #line 500 "src/lexer-keywords.txt" {"get_global", TokenType::GlobalGet, Opcode::GlobalGet}, {""}, -#line 438 "src/lexer-keywords.txt" +#line 436 "src/lexer-keywords.txt" {"memory.grow", TokenType::MemoryGrow, Opcode::MemoryGrow}, {""}, {""}, {""}, -#line 360 "src/lexer-keywords.txt" +#line 358 "src/lexer-keywords.txt" {"i64.popcnt", TokenType::Unary, Opcode::I64Popcnt}, -#line 241 "src/lexer-keywords.txt" +#line 239 "src/lexer-keywords.txt" {"i32.popcnt", TokenType::Unary, Opcode::I32Popcnt}, {""}, {""}, #line 495 "src/lexer-keywords.txt" @@ -1164,125 +1165,125 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 484 "src/lexer-keywords.txt" {"v8x16.swizzle", TokenType::Binary, Opcode::V8X16Swizzle}, {""}, {""}, -#line 310 "src/lexer-keywords.txt" +#line 308 "src/lexer-keywords.txt" {"i64.atomic.rmw32.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XorU}, {""}, {""}, -#line 423 "src/lexer-keywords.txt" +#line 421 "src/lexer-keywords.txt" {"i8x16.splat", TokenType::Unary, Opcode::I8X16Splat}, {""}, {""}, {""}, -#line 337 "src/lexer-keywords.txt" +#line 335 "src/lexer-keywords.txt" {"i64.extend16_s", TokenType::Unary, Opcode::I64Extend16S}, -#line 223 "src/lexer-keywords.txt" +#line 221 "src/lexer-keywords.txt" {"i32.extend16_s", TokenType::Unary, Opcode::I32Extend16S}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 242 "src/lexer-keywords.txt" +#line 240 "src/lexer-keywords.txt" {"i32.reinterpret_f32", TokenType::Convert, Opcode::I32ReinterpretF32}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 409 "src/lexer-keywords.txt" +#line 407 "src/lexer-keywords.txt" {"i8x16.gt_s", TokenType::Compare, Opcode::I8X16GtS}, -#line 181 "src/lexer-keywords.txt" +#line 179 "src/lexer-keywords.txt" {"i16x8.splat", TokenType::Unary, Opcode::I16X8Splat}, -#line 410 "src/lexer-keywords.txt" +#line 408 "src/lexer-keywords.txt" {"i8x16.gt_u", TokenType::Compare, Opcode::I8X16GtU}, -#line 361 "src/lexer-keywords.txt" +#line 359 "src/lexer-keywords.txt" {"i64.reinterpret_f64", TokenType::Convert, Opcode::I64ReinterpretF64}, #line 498 "src/lexer-keywords.txt" {"f64.promote/f32", TokenType::Convert, Opcode::F64PromoteF32}, {""}, -#line 407 "src/lexer-keywords.txt" +#line 405 "src/lexer-keywords.txt" {"i8x16.ge_s", TokenType::Compare, Opcode::I8X16GeS}, {""}, -#line 408 "src/lexer-keywords.txt" +#line 406 "src/lexer-keywords.txt" {"i8x16.ge_u", TokenType::Compare, Opcode::I8X16GeU}, {""}, {""}, {""}, {""}, -#line 282 "src/lexer-keywords.txt" +#line 280 "src/lexer-keywords.txt" {"i32x4.shl", TokenType::Binary, Opcode::I32X4Shl}, -#line 116 "src/lexer-keywords.txt" +#line 114 "src/lexer-keywords.txt" {"f64.max", TokenType::Binary, Opcode::F64Max}, -#line 66 "src/lexer-keywords.txt" +#line 64 "src/lexer-keywords.txt" {"f32.max", TokenType::Binary, Opcode::F32Max}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 167 "src/lexer-keywords.txt" +#line 165 "src/lexer-keywords.txt" {"i16x8.gt_s", TokenType::Compare, Opcode::I16X8GtS}, {""}, -#line 168 "src/lexer-keywords.txt" +#line 166 "src/lexer-keywords.txt" {"i16x8.gt_u", TokenType::Compare, Opcode::I16X8GtU}, {""}, {""}, -#line 309 "src/lexer-keywords.txt" +#line 307 "src/lexer-keywords.txt" {"i64.atomic.rmw32.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XchgU}, -#line 165 "src/lexer-keywords.txt" +#line 163 "src/lexer-keywords.txt" {"i16x8.ge_s", TokenType::Compare, Opcode::I16X8GeS}, {""}, -#line 166 "src/lexer-keywords.txt" +#line 164 "src/lexer-keywords.txt" {"i16x8.ge_u", TokenType::Compare, Opcode::I16X8GeU}, -#line 263 "src/lexer-keywords.txt" +#line 261 "src/lexer-keywords.txt" {"i32.wrap_i64", TokenType::Convert, Opcode::I32WrapI64}, -#line 109 "src/lexer-keywords.txt" +#line 107 "src/lexer-keywords.txt" {"f64.eq", TokenType::Compare, Opcode::F64Eq}, -#line 59 "src/lexer-keywords.txt" +#line 57 "src/lexer-keywords.txt" {"f32.eq", TokenType::Compare, Opcode::F32Eq}, {""}, -#line 335 "src/lexer-keywords.txt" +#line 333 "src/lexer-keywords.txt" {"i64.eq", TokenType::Compare, Opcode::I64Eq}, -#line 221 "src/lexer-keywords.txt" +#line 219 "src/lexer-keywords.txt" {"i32.eq", TokenType::Compare, Opcode::I32Eq}, {""}, {""}, {""}, -#line 283 "src/lexer-keywords.txt" +#line 281 "src/lexer-keywords.txt" {"i32x4.shr_s", TokenType::Binary, Opcode::I32X4ShrS}, {""}, {""}, {""}, -#line 284 "src/lexer-keywords.txt" +#line 282 "src/lexer-keywords.txt" {"i32x4.shr_u", TokenType::Binary, Opcode::I32X4ShrU}, -#line 339 "src/lexer-keywords.txt" +#line 337 "src/lexer-keywords.txt" {"i64.extend8_s", TokenType::Unary, Opcode::I64Extend8S}, -#line 224 "src/lexer-keywords.txt" +#line 222 "src/lexer-keywords.txt" {"i32.extend8_s", TokenType::Unary, Opcode::I32Extend8S}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 266 "src/lexer-keywords.txt" +#line 264 "src/lexer-keywords.txt" {"i32x4.any_true", TokenType::Unary, Opcode::I32X4AnyTrue}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 413 "src/lexer-keywords.txt" +#line 411 "src/lexer-keywords.txt" {"i8x16.load_splat", TokenType::Load, Opcode::I8X16LoadSplat}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 94 "src/lexer-keywords.txt" +#line 92 "src/lexer-keywords.txt" {"f32x4.replace_lane", TokenType::SimdLaneOp, Opcode::F32X4ReplaceLane}, {""}, {""}, -#line 281 "src/lexer-keywords.txt" +#line 279 "src/lexer-keywords.txt" {"i32x4.replace_lane", TokenType::SimdLaneOp, Opcode::I32X4ReplaceLane}, {""}, {""}, {""}, {""}, -#line 96 "src/lexer-keywords.txt" +#line 94 "src/lexer-keywords.txt" {"f32x4.sqrt", TokenType::Unary, Opcode::F32X4Sqrt}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 303 "src/lexer-keywords.txt" +#line 301 "src/lexer-keywords.txt" {"i64.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XorU}, -#line 197 "src/lexer-keywords.txt" +#line 195 "src/lexer-keywords.txt" {"i32.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XorU}, -#line 171 "src/lexer-keywords.txt" +#line 169 "src/lexer-keywords.txt" {"i16x8.load_splat", TokenType::Load, Opcode::I16X8LoadSplat}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, #line 502 "src/lexer-keywords.txt" {"i32.reinterpret/f32", TokenType::Convert, Opcode::I32ReinterpretF32}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 107 "src/lexer-keywords.txt" +#line 105 "src/lexer-keywords.txt" {"f64.copysign", TokenType::Binary, Opcode::F64Copysign}, -#line 56 "src/lexer-keywords.txt" +#line 54 "src/lexer-keywords.txt" {"f32.copysign", TokenType::Binary, Opcode::F32Copysign}, {""}, #line 514 "src/lexer-keywords.txt" {"i64.reinterpret/f64", TokenType::Convert, Opcode::I64ReinterpretF64}, {""}, {""}, {""}, {""}, -#line 185 "src/lexer-keywords.txt" +#line 183 "src/lexer-keywords.txt" {"i16x8", TokenType::I16X8}, {""}, -#line 92 "src/lexer-keywords.txt" +#line 90 "src/lexer-keywords.txt" {"f32x4.neg", TokenType::Unary, Opcode::F32X4Neg}, -#line 28 "src/lexer-keywords.txt" +#line 26 "src/lexer-keywords.txt" {"atomic.notify", TokenType::AtomicNotify, Opcode::AtomicNotify}, {""}, -#line 279 "src/lexer-keywords.txt" +#line 277 "src/lexer-keywords.txt" {"i32x4.neg", TokenType::Unary, Opcode::I32X4Neg}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, @@ -1290,87 +1291,87 @@ Perfect_Hash::InWordSet (const char *str, size_t len) #line 511 "src/lexer-keywords.txt" {"i32.wrap/i64", TokenType::Convert, Opcode::I32WrapI64}, {""}, -#line 302 "src/lexer-keywords.txt" +#line 300 "src/lexer-keywords.txt" {"i64.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XchgU}, -#line 196 "src/lexer-keywords.txt" +#line 194 "src/lexer-keywords.txt" {"i32.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XchgU}, {""}, {""}, {""}, {""}, {""}, -#line 140 "src/lexer-keywords.txt" +#line 138 "src/lexer-keywords.txt" {"f64x2.max", TokenType::Binary, Opcode::F64X2Max}, {""}, {""}, {""}, {""}, -#line 420 "src/lexer-keywords.txt" +#line 418 "src/lexer-keywords.txt" {"i8x16.shl", TokenType::Binary, Opcode::I8X16Shl}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 324 "src/lexer-keywords.txt" +#line 322 "src/lexer-keywords.txt" {"i64.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I64AtomicRmwXor}, -#line 211 "src/lexer-keywords.txt" +#line 209 "src/lexer-keywords.txt" {"i32.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I32AtomicRmwXor}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 38 "src/lexer-keywords.txt" +#line 36 "src/lexer-keywords.txt" {"current_memory", TokenType::MemorySize, Opcode::MemorySize}, -#line 327 "src/lexer-keywords.txt" +#line 325 "src/lexer-keywords.txt" {"i64.atomic.store8", TokenType::AtomicStore, Opcode::I64AtomicStore8}, -#line 213 "src/lexer-keywords.txt" +#line 211 "src/lexer-keywords.txt" {"i32.atomic.store8", TokenType::AtomicStore, Opcode::I32AtomicStore8}, {""}, {""}, -#line 134 "src/lexer-keywords.txt" +#line 132 "src/lexer-keywords.txt" {"f64x2.eq", TokenType::Compare, Opcode::F64X2Eq}, -#line 288 "src/lexer-keywords.txt" +#line 286 "src/lexer-keywords.txt" {"i32x4.trunc_sat_f32x4_s", TokenType::Unary, Opcode::I32X4TruncSatF32X4S}, -#line 178 "src/lexer-keywords.txt" +#line 176 "src/lexer-keywords.txt" {"i16x8.shl", TokenType::Binary, Opcode::I16X8Shl}, -#line 289 "src/lexer-keywords.txt" +#line 287 "src/lexer-keywords.txt" {"i32x4.trunc_sat_f32x4_u", TokenType::Unary, Opcode::I32X4TruncSatF32X4U}, {""}, {""}, {""}, -#line 421 "src/lexer-keywords.txt" +#line 419 "src/lexer-keywords.txt" {"i8x16.shr_s", TokenType::Binary, Opcode::I8X16ShrS}, {""}, {""}, {""}, -#line 422 "src/lexer-keywords.txt" +#line 420 "src/lexer-keywords.txt" {"i8x16.shr_u", TokenType::Binary, Opcode::I8X16ShrU}, {""}, -#line 84 "src/lexer-keywords.txt" +#line 82 "src/lexer-keywords.txt" {"f32x4.extract_lane", TokenType::SimdLaneOp, Opcode::F32X4ExtractLane}, {""}, {""}, -#line 268 "src/lexer-keywords.txt" +#line 266 "src/lexer-keywords.txt" {"i32x4.extract_lane", TokenType::SimdLaneOp, Opcode::I32X4ExtractLane}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 403 "src/lexer-keywords.txt" +#line 401 "src/lexer-keywords.txt" {"i8x16.any_true", TokenType::Unary, Opcode::I8X16AnyTrue}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 179 "src/lexer-keywords.txt" +#line 177 "src/lexer-keywords.txt" {"i16x8.shr_s", TokenType::Binary, Opcode::I16X8ShrS}, {""}, {""}, {""}, -#line 180 "src/lexer-keywords.txt" +#line 178 "src/lexer-keywords.txt" {"i16x8.shr_u", TokenType::Binary, Opcode::I16X8ShrU}, #line 485 "src/lexer-keywords.txt" {"v8x16.shuffle", TokenType::SimdShuffleOp, Opcode::V8X16Shuffle}, {""}, {""}, {""}, -#line 419 "src/lexer-keywords.txt" +#line 417 "src/lexer-keywords.txt" {"i8x16.replace_lane", TokenType::SimdLaneOp, Opcode::I8X16ReplaceLane}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 161 "src/lexer-keywords.txt" +#line 159 "src/lexer-keywords.txt" {"i16x8.any_true", TokenType::Unary, Opcode::I16X8AnyTrue}, {""}, {""}, -#line 156 "src/lexer-keywords.txt" +#line 154 "src/lexer-keywords.txt" {"grow_memory", TokenType::MemoryGrow, Opcode::MemoryGrow}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 177 "src/lexer-keywords.txt" +#line 175 "src/lexer-keywords.txt" {"i16x8.replace_lane", TokenType::SimdLaneOp, Opcode::I16X8ReplaceLane}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 316 "src/lexer-keywords.txt" +#line 314 "src/lexer-keywords.txt" {"i64.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XchgU}, -#line 203 "src/lexer-keywords.txt" +#line 201 "src/lexer-keywords.txt" {"i32.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XchgU}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 417 "src/lexer-keywords.txt" +#line 415 "src/lexer-keywords.txt" {"i8x16.neg", TokenType::Unary, Opcode::I8X16Neg}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 175 "src/lexer-keywords.txt" +#line 173 "src/lexer-keywords.txt" {"i16x8.neg", TokenType::Unary, Opcode::I16X8Neg}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, @@ -1378,53 +1379,53 @@ Perfect_Hash::InWordSet (const char *str, size_t len) {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 405 "src/lexer-keywords.txt" +#line 403 "src/lexer-keywords.txt" {"i8x16.extract_lane_s", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneS}, {""}, -#line 406 "src/lexer-keywords.txt" +#line 404 "src/lexer-keywords.txt" {"i8x16.extract_lane_u", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneU}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 163 "src/lexer-keywords.txt" +#line 161 "src/lexer-keywords.txt" {"i16x8.extract_lane_s", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneS}, {""}, -#line 164 "src/lexer-keywords.txt" +#line 162 "src/lexer-keywords.txt" {"i16x8.extract_lane_u", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneU}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 320 "src/lexer-keywords.txt" +#line 318 "src/lexer-keywords.txt" {"i64.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmwCmpxchg}, -#line 207 "src/lexer-keywords.txt" +#line 205 "src/lexer-keywords.txt" {"i32.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmwCmpxchg}, {""}, -#line 436 "src/lexer-keywords.txt" +#line 434 "src/lexer-keywords.txt" {"memory.copy", TokenType::MemoryCopy, Opcode::MemoryCopy}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 89 "src/lexer-keywords.txt" +#line 87 "src/lexer-keywords.txt" {"f32x4.max", TokenType::Binary, Opcode::F32X4Max}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 83 "src/lexer-keywords.txt" +#line 81 "src/lexer-keywords.txt" {"f32x4.eq", TokenType::Compare, Opcode::F32X4Eq}, {""}, {""}, -#line 267 "src/lexer-keywords.txt" +#line 265 "src/lexer-keywords.txt" {"i32x4.eq", TokenType::Compare, Opcode::I32X4Eq}, {""}, {""}, -#line 80 "src/lexer-keywords.txt" +#line 78 "src/lexer-keywords.txt" {"f32x4.convert_i32x4_s", TokenType::Unary, Opcode::F32X4ConvertI32X4S}, {""}, -#line 81 "src/lexer-keywords.txt" +#line 79 "src/lexer-keywords.txt" {"f32x4.convert_i32x4_u", TokenType::Unary, Opcode::F32X4ConvertI32X4U}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 131 "src/lexer-keywords.txt" +#line 129 "src/lexer-keywords.txt" {"f64x2.convert_i64x2_s", TokenType::Unary, Opcode::F64X2ConvertI64X2S}, {""}, -#line 132 "src/lexer-keywords.txt" +#line 130 "src/lexer-keywords.txt" {"f64x2.convert_i64x2_u", TokenType::Unary, Opcode::F64X2ConvertI64X2U}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, @@ -1441,12 +1442,12 @@ Perfect_Hash::InWordSet (const char *str, size_t len) {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 404 "src/lexer-keywords.txt" +#line 402 "src/lexer-keywords.txt" {"i8x16.eq", TokenType::Compare, Opcode::I8X16Eq}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 162 "src/lexer-keywords.txt" +#line 160 "src/lexer-keywords.txt" {"i16x8.eq", TokenType::Compare, Opcode::I16X8Eq}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, @@ -1468,9 +1469,9 @@ Perfect_Hash::InWordSet (const char *str, size_t len) {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 323 "src/lexer-keywords.txt" +#line 321 "src/lexer-keywords.txt" {"i64.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I64AtomicRmwXchg}, -#line 210 "src/lexer-keywords.txt" +#line 208 "src/lexer-keywords.txt" {"i32.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I32AtomicRmwXchg} }; diff --git a/src/resolve-names.cc b/src/resolve-names.cc index 0e81cad1..6210c1bf 100644 --- a/src/resolve-names.cc +++ b/src/resolve-names.cc @@ -515,8 +515,6 @@ void NameResolver::VisitCommand(Command* command) { case CommandType::Action: case CommandType::AssertReturn: case CommandType::AssertReturnFunc: - case CommandType::AssertReturnCanonicalNan: - case CommandType::AssertReturnArithmeticNan: case CommandType::AssertTrap: case CommandType::AssertExhaustion: case CommandType::Register: diff --git a/src/token.def b/src/token.def index 87c4749c..54f68564 100644 --- a/src/token.def +++ b/src/token.def @@ -25,8 +25,6 @@ WABT_TOKEN(AssertInvalid, "assert_invalid") WABT_TOKEN(AssertMalformed, "assert_malformed") WABT_TOKEN(AssertReturn, "assert_return") WABT_TOKEN(AssertReturnFunc, "assert_return_func") -WABT_TOKEN(AssertReturnArithmeticNan, "assert_return_arithmetic_nan") -WABT_TOKEN(AssertReturnCanonicalNan, "assert_return_canonical_nan") WABT_TOKEN(AssertTrap, "assert_trap") WABT_TOKEN(AssertUnlinkable, "assert_unlinkable") WABT_TOKEN(Bin, "bin") @@ -45,6 +43,8 @@ WABT_TOKEN(Lpar, "(") WABT_TOKEN(Memory, "memory") WABT_TOKEN(Module, "module") WABT_TOKEN(Mut, "mut") +WABT_TOKEN(NanArithmetic, "nan:arithmetic") +WABT_TOKEN(NanCanonical, "nan:canonical") WABT_TOKEN(Offset, "offset") WABT_TOKEN(Param, "param") WABT_TOKEN(Quote, "quote") diff --git a/src/tools/spectest-interp.cc b/src/tools/spectest-interp.cc index 57f9e855..f335e572 100644 --- a/src/tools/spectest-interp.cc +++ b/src/tools/spectest-interp.cc @@ -150,10 +150,6 @@ class ActionCommandBase : public CommandMixin<TypeEnum> { }; typedef ActionCommandBase<CommandType::Action> ActionCommand; -typedef ActionCommandBase<CommandType::AssertReturnCanonicalNan> - AssertReturnCanonicalNanCommand; -typedef ActionCommandBase<CommandType::AssertReturnArithmeticNan> - AssertReturnArithmeticNanCommand; class RegisterCommand : public CommandMixin<CommandType::Register> { public: @@ -161,10 +157,16 @@ class RegisterCommand : public CommandMixin<CommandType::Register> { std::string name; }; +struct ExpectedValue { + bool is_expected_nan; + TypedValue value; + ExpectedNan expectedNan; +}; + class AssertReturnCommand : public CommandMixin<CommandType::AssertReturn> { public: Action action; - TypedValues expected; + std::vector<ExpectedValue> expected; }; class AssertReturnFuncCommand @@ -226,7 +228,12 @@ class JSONParser { wabt::Result ParseTypeObject(Type* out_type); wabt::Result ParseTypeVector(TypeVector* out_types); wabt::Result ParseConst(TypedValue* out_value); + wabt::Result ParseConstValue(TypedValue* out_value, + string_view type_str, + string_view value_str); wabt::Result ParseConstVector(TypedValues* out_values); + wabt::Result ParseExpectedValue(ExpectedValue* out_value); + wabt::Result ParseExpectedValues(std::vector<ExpectedValue>* out_values); wabt::Result ParseAction(Action* out_action); wabt::Result ParseActionResult(); wabt::Result ParseModuleType(ModuleType* out_type); @@ -496,9 +503,14 @@ wabt::Result JSONParser::ParseConst(TypedValue* out_value) { PARSE_KEY_STRING_VALUE("value", &value_str); EXPECT("}"); + return ParseConstValue(out_value, type_str, value_str); +} + +wabt::Result JSONParser::ParseConstValue(TypedValue* out_value, + string_view type_str, + string_view value_str) { const char* value_start = value_str.data(); const char* value_end = value_str.data() + value_str.size(); - if (type_str == "i32") { uint32_t value; if (Failed((ParseInt32(value_start, value_end, &value, @@ -564,13 +576,56 @@ wabt::Result JSONParser::ParseConst(TypedValue* out_value) { out_value->type = Type::Funcref; out_value->value.ref = {RefType::Func, value}; } else { - PrintError("unknown concrete type: \"%s\"", type_str.c_str()); + PrintError("unknown concrete type: \"%s\"", type_str.to_string().c_str()); return wabt::Result::Error; } return wabt::Result::Ok; } +wabt::Result JSONParser::ParseExpectedValue(ExpectedValue* out_value) { + std::string type_str; + std::string value_str; + EXPECT("{"); + PARSE_KEY_STRING_VALUE("type", &type_str); + EXPECT(","); + PARSE_KEY_STRING_VALUE("value", &value_str); + EXPECT("}"); + + if (type_str == "f32" || type_str == "f64") { + if (value_str == "nan:canonical") { + out_value->value.type = type_str == "f32" ? Type::F32 : Type::F64; + out_value->is_expected_nan = true; + out_value->expectedNan = ExpectedNan::Canonical; + return wabt::Result::Ok; + } else if (value_str == "nan:arithmetic") { + out_value->value.type = type_str == "f32" ? Type::F32 : Type::F64; + out_value->is_expected_nan = true; + out_value->expectedNan = ExpectedNan::Arithmetic; + return wabt::Result::Ok; + } + } + + out_value->is_expected_nan = false; + return ParseConstValue(&out_value->value, type_str, value_str); +} + +wabt::Result JSONParser::ParseExpectedValues(std::vector<ExpectedValue>* out_values) { + out_values->clear(); + EXPECT("["); + bool first = true; + while (!Match("]")) { + if (!first) { + EXPECT(","); + } + ExpectedValue value; + CHECK_RESULT(ParseExpectedValue(&value)); + out_values->push_back(value); + first = false; + } + return wabt::Result::Ok; +} + wabt::Result JSONParser::ParseConstVector(TypedValues* out_values) { out_values->clear(); EXPECT("["); @@ -759,7 +814,7 @@ wabt::Result JSONParser::ParseCommand(CommandPtr* out_command) { CHECK_RESULT(ParseAction(&command->action)); EXPECT(","); EXPECT_KEY("expected"); - CHECK_RESULT(ParseConstVector(&command->expected)); + CHECK_RESULT(ParseExpectedValues(&command->expected)); *out_command = std::move(command); } else if (Match("\"assert_return_func\"")) { auto command = MakeUnique<AssertReturnFuncCommand>(); @@ -768,24 +823,6 @@ wabt::Result JSONParser::ParseCommand(CommandPtr* out_command) { EXPECT(","); CHECK_RESULT(ParseAction(&command->action)); *out_command = std::move(command); - } else if (Match("\"assert_return_canonical_nan\"")) { - auto command = MakeUnique<AssertReturnCanonicalNanCommand>(); - EXPECT(","); - CHECK_RESULT(ParseLine(&command->line)); - EXPECT(","); - CHECK_RESULT(ParseAction(&command->action)); - EXPECT(","); - CHECK_RESULT(ParseActionResult()); - *out_command = std::move(command); - } else if (Match("\"assert_return_arithmetic_nan\"")) { - auto command = MakeUnique<AssertReturnArithmeticNanCommand>(); - EXPECT(","); - CHECK_RESULT(ParseLine(&command->line)); - EXPECT(","); - CHECK_RESULT(ParseAction(&command->action)); - EXPECT(","); - CHECK_RESULT(ParseActionResult()); - *out_command = std::move(command); } else if (Match("\"assert_trap\"")) { auto command = MakeUnique<AssertTrapCommand>(); EXPECT(","); @@ -862,8 +899,6 @@ class CommandRunner { const AssertUninstantiableCommand*); wabt::Result OnAssertReturnCommand(const AssertReturnCommand*); wabt::Result OnAssertReturnFuncCommand(const AssertReturnFuncCommand*); - template <typename NanCommand> - wabt::Result OnAssertReturnNanCommand(const NanCommand*); wabt::Result OnAssertTrapCommand(const AssertTrapCommand*); wabt::Result OnAssertExhaustionCommand(const AssertExhaustionCommand*); @@ -974,16 +1009,6 @@ wabt::Result CommandRunner::Run(const Script& script) { OnAssertReturnFuncCommand(cast<AssertReturnFuncCommand>(command.get()))); break; - case CommandType::AssertReturnCanonicalNan: - TallyCommand(OnAssertReturnNanCommand( - cast<AssertReturnCanonicalNanCommand>(command.get()))); - break; - - case CommandType::AssertReturnArithmeticNan: - TallyCommand(OnAssertReturnNanCommand( - cast<AssertReturnArithmeticNanCommand>(command.get()))); - break; - case CommandType::AssertTrap: TallyCommand( OnAssertTrapCommand(cast<AssertTrapCommand>(command.get()))); @@ -1364,73 +1389,43 @@ wabt::Result CommandRunner::OnAssertReturnCommand( wabt::Result result = wabt::Result::Ok; for (size_t i = 0; i < exec_result.values.size(); ++i) { - const TypedValue& expected_tv = command->expected[i]; - const TypedValue& actual_tv = exec_result.values[i]; - if (!TypedValuesAreEqual(expected_tv, actual_tv)) { - PrintError(command->line, - "mismatch in result %" PRIzd - " of assert_return: expected %s, got %s", - i, TypedValueToString(expected_tv).c_str(), - TypedValueToString(actual_tv).c_str()); - result = wabt::Result::Error; - } - } - - return result; -} - -template <typename NanCommand> -wabt::Result CommandRunner::OnAssertReturnNanCommand( - const NanCommand* command) { - ExecResult exec_result = - RunAction(command->line, &command->action, RunVerbosity::Quiet); - - if (!exec_result.ok()) { - PrintError(command->line, "unexpected trap: %s", - ResultToString(exec_result.result).c_str()); - return wabt::Result::Error; - } - - if (exec_result.values.size() != 1) { - PrintError(command->line, "expected one result, got %" PRIzd, - exec_result.values.size()); - return wabt::Result::Error; - } - - const bool is_canonical = - command->type == CommandType::AssertReturnCanonicalNan; - - const TypedValue& actual = exec_result.values[0]; - switch (actual.type) { - case Type::F32: { - bool is_nan = is_canonical ? IsCanonicalNan(actual.value.f32_bits) - : IsArithmeticNan(actual.value.f32_bits); + const ExpectedValue& expected = command->expected[i]; + const TypedValue& actual = exec_result.values[i]; + if (expected.is_expected_nan) { + bool is_nan; + if (expected.expectedNan == ExpectedNan::Arithmetic) { + if (expected.value.type == Type::F64) { + is_nan = IsArithmeticNan(actual.value.f64_bits); + } else { + is_nan = IsArithmeticNan(actual.value.f32_bits); + } + } else if (expected.expectedNan == ExpectedNan::Canonical) { + if (expected.value.type == Type::F64) { + is_nan = IsCanonicalNan(actual.value.f64_bits); + } else { + is_nan = IsCanonicalNan(actual.value.f32_bits); + } + } else { + WABT_UNREACHABLE; + } if (!is_nan) { PrintError(command->line, "expected result to be nan, got %s", TypedValueToString(actual).c_str()); - return wabt::Result::Error; + result = wabt::Result::Error; } - break; - } - - case Type::F64: { - bool is_nan = is_canonical ? IsCanonicalNan(actual.value.f64_bits) - : IsArithmeticNan(actual.value.f64_bits); - if (!is_nan) { - PrintError(command->line, "expected result to be nan, got %s", + } else { + if (!TypedValuesAreEqual(expected.value, actual)) { + PrintError(command->line, + "mismatch in result %" PRIzd + " of assert_return: expected %s, got %s", + i, TypedValueToString(expected.value).c_str(), TypedValueToString(actual).c_str()); - return wabt::Result::Error; + result = wabt::Result::Error; } - break; } - - default: - PrintError(command->line, "expected result type to be f32 or f64, got %s", - GetTypeName(actual.type)); - return wabt::Result::Error; } - return wabt::Result::Ok; + return result; } wabt::Result CommandRunner::OnAssertTrapCommand( diff --git a/src/validator.cc b/src/validator.cc index c9b083dd..8a71af05 100644 --- a/src/validator.cc +++ b/src/validator.cc @@ -166,9 +166,6 @@ class Validator : public ExprVisitor::Delegate { const TypeVector& actual, const TypeVector& expected, const char* desc); - void CheckAssertReturnNanType(const Location* loc, - Type actual, - const char* desc); void CheckExprList(const Location* loc, const ExprList& exprs); bool CheckHasMemory(const Location* loc, Opcode opcode); bool CheckHasTable(const Location* loc, Opcode opcode, Index index = 0); @@ -203,7 +200,6 @@ class Validator : public ExprVisitor::Delegate { const TypeVector* CheckInvoke(const InvokeAction* action); Result CheckGet(const GetAction* action, Type* out_type); ActionResult CheckAction(const Action* action); - void CheckAssertReturnNanCommand(const Action* action); void CheckCommand(const Command* command); void CheckEvent(const Location* loc, const Event* Event); @@ -462,17 +458,6 @@ void Validator::CheckResultTypes(const Location* loc, } } -void Validator::CheckAssertReturnNanType(const Location* loc, - Type actual, - const char* desc) { - // When using assert_return_nan, the result can be either a f32 or f64 type - // so we special case it here. - if (actual != Type::F32 && actual != Type::F64) { - PrintError(loc, "type mismatch at %s. got %s, expected f32 or f64", desc, - GetTypeName(actual)); - } -} - void Validator::CheckExprList(const Location* loc, const ExprList& exprs) { ExprVisitor visitor(this); // TODO(binji): Add const-visitors. @@ -1478,29 +1463,6 @@ Validator::ActionResult Validator::CheckAction(const Action* action) { return result; } -void Validator::CheckAssertReturnNanCommand(const Action* action) { - ActionResult result = CheckAction(action); - - // A valid result type will either be f32 or f64; convert a Types result into - // a Type result, so it is easier to check below. Type::Any is used to - // specify a type that should not be checked (because an earlier error - // occurred). - if (result.kind == ActionResult::Kind::Types) { - if (result.types->size() == 1) { - result.kind = ActionResult::Kind::Type; - result.type = (*result.types)[0]; - } else { - PrintError(&action->loc, "expected 1 result, got %" PRIzd, - result.types->size()); - result.type = Type::Any; - } - } - - if (result.kind == ActionResult::Kind::Type && result.type != Type::Any) { - CheckAssertReturnNanType(&action->loc, result.type, "action"); - } -} - void Validator::CheckCommand(const Command* command) { switch (command->type) { case CommandType::Module: @@ -1553,16 +1515,6 @@ void Validator::CheckCommand(const Command* command) { break; } - case CommandType::AssertReturnCanonicalNan: - CheckAssertReturnNanCommand( - cast<AssertReturnCanonicalNanCommand>(command)->action.get()); - break; - - case CommandType::AssertReturnArithmeticNan: - CheckAssertReturnNanCommand( - cast<AssertReturnArithmeticNanCommand>(command)->action.get()); - break; - case CommandType::AssertTrap: // ignore result type. CheckAction(cast<AssertTrapCommand>(command)->action.get()); diff --git a/src/wast-parser.cc b/src/wast-parser.cc index 00c95c81..79126431 100644 --- a/src/wast-parser.cc +++ b/src/wast-parser.cc @@ -223,8 +223,6 @@ bool IsCommand(TokenTypePair pair) { case TokenType::AssertMalformed: case TokenType::AssertReturn: case TokenType::AssertReturnFunc: - case TokenType::AssertReturnArithmeticNan: - case TokenType::AssertReturnCanonicalNan: case TokenType::AssertTrap: case TokenType::AssertUnlinkable: case TokenType::Get: @@ -1654,7 +1652,7 @@ Result WastParser::ParsePlainInstr(std::unique_ptr<Expr>* out_expr) { case TokenType::Const: { Const const_; - CHECK_RESULT(ParseConst(&const_)); + CHECK_RESULT(ParseConst(&const_, ConstType::Normal)); out_expr->reset(new ConstExpr(const_, loc)); break; } @@ -2004,7 +2002,24 @@ Result WastParser::ParseSimdV128Const(Const* const_, TokenType token_type) { return Result::Ok; } -Result WastParser::ParseConst(Const* const_) { +Result WastParser::ParseExpectedNan(ExpectedNan* expected) { + WABT_TRACE(ParseExpectedNan); + TokenType token_type = Peek(); + switch (token_type) { + case TokenType::NanArithmetic: + *expected = ExpectedNan::Arithmetic; + break; + case TokenType::NanCanonical: + *expected = ExpectedNan::Canonical; + break; + default: + return Result::Error; + } + Consume(); + return Result::Ok; +} + +Result WastParser::ParseConst(Const* const_, ConstType type) { WABT_TRACE(ParseConst); Token token = Consume(); Opcode opcode = token.opcode(); @@ -2027,6 +2042,9 @@ Result WastParser::ParseConst(Const* const_) { end = sv.end(); break; } + case TokenType::NanArithmetic: + case TokenType::NanCanonical: + break; default: return ErrorExpected({"a numeric literal"}, "123, -45, 6.7e8"); } @@ -2048,11 +2066,21 @@ Result WastParser::ParseConst(Const* const_) { case Opcode::F32Const: const_->type = Type::F32; + if (type == ConstType::Expectation && + ParseExpectedNan(&const_->expected) == Result::Ok) { + const_->is_expected_nan = true; + break; + } result = ParseFloat(literal.type, s, end, &const_->f32_bits); break; case Opcode::F64Const: const_->type = Type::F64; + if (type == ConstType::Expectation && + ParseExpectedNan(&const_->expected) == Result::Ok) { + const_->is_expected_nan = true; + break; + } result = ParseDouble(literal.type, s, end, &const_->f64_bits); break; @@ -2127,7 +2155,7 @@ Result WastParser::ParseHostRef(Const* const_) { return Result::Ok; } -Result WastParser::ParseConstList(ConstVector* consts) { +Result WastParser::ParseConstList(ConstVector* consts, ConstType type) { WABT_TRACE(ParseConstList); while (PeekMatchLpar(TokenType::Const) || PeekMatchLpar(TokenType::RefNull) || PeekMatchLpar(TokenType::RefHost)) { @@ -2135,7 +2163,7 @@ Result WastParser::ParseConstList(ConstVector* consts) { Const const_; switch (Peek()) { case TokenType::Const: - CHECK_RESULT(ParseConst(&const_)); + CHECK_RESULT(ParseConst(&const_, type)); break; case TokenType::RefNull: { auto token = Consume(); @@ -2435,12 +2463,6 @@ Result WastParser::ParseCommand(Script* script, CommandPtr* out_command) { case TokenType::AssertReturnFunc: return ParseAssertReturnFuncCommand(out_command); - case TokenType::AssertReturnArithmeticNan: - return ParseAssertReturnArithmeticNanCommand(out_command); - - case TokenType::AssertReturnCanonicalNan: - return ParseAssertReturnCanonicalNanCommand(out_command); - case TokenType::AssertTrap: return ParseAssertTrapCommand(out_command); @@ -2487,7 +2509,7 @@ Result WastParser::ParseAssertReturnCommand(CommandPtr* out_command) { EXPECT(AssertReturn); auto command = MakeUnique<AssertReturnCommand>(); CHECK_RESULT(ParseAction(&command->action)); - CHECK_RESULT(ParseConstList(&command->expected)); + CHECK_RESULT(ParseConstList(&command->expected, ConstType::Expectation)); EXPECT(Rpar); *out_command = std::move(command); return Result::Ok; @@ -2504,20 +2526,6 @@ Result WastParser::ParseAssertReturnFuncCommand(CommandPtr* out_command) { return Result::Ok; } -Result WastParser::ParseAssertReturnArithmeticNanCommand( - CommandPtr* out_command) { - WABT_TRACE(ParseAssertReturnArithmeticNanCommand); - return ParseAssertActionCommand<AssertReturnArithmeticNanCommand>( - TokenType::AssertReturnArithmeticNan, out_command); -} - -Result WastParser::ParseAssertReturnCanonicalNanCommand( - CommandPtr* out_command) { - WABT_TRACE(ParseAssertReturnCanonicalNanCommand); - return ParseAssertActionCommand<AssertReturnCanonicalNanCommand>( - TokenType::AssertReturnCanonicalNan, out_command); -} - Result WastParser::ParseAssertTrapCommand(CommandPtr* out_command) { WABT_TRACE(ParseAssertTrapCommand); EXPECT(Lpar); @@ -2635,7 +2643,7 @@ Result WastParser::ParseAction(ActionPtr* out_action) { auto action = MakeUnique<InvokeAction>(loc); ParseVarOpt(&action->module_var, Var(last_module_index_, loc)); CHECK_RESULT(ParseQuotedText(&action->name)); - CHECK_RESULT(ParseConstList(&action->args)); + CHECK_RESULT(ParseConstList(&action->args, ConstType::Normal)); *out_action = std::move(action); break; } diff --git a/src/wast-parser.h b/src/wast-parser.h index 712861e6..864643d6 100644 --- a/src/wast-parser.h +++ b/src/wast-parser.h @@ -48,6 +48,11 @@ class WastParser { std::unique_ptr<Script> ReleaseScript(); private: + enum class ConstType { + Normal, + Expectation, + }; + void ErrorUnlessOpcodeEnabled(const Token&); // Print an error message listing the expected tokens, as well as an example @@ -163,9 +168,10 @@ class WastParser { Result ParseTerminatingInstrList(ExprList*); Result ParseInstr(ExprList*); Result ParsePlainInstr(std::unique_ptr<Expr>*); - Result ParseConst(Const*); + Result ParseConst(Const*, ConstType type); Result ParseHostRef(Const*); - Result ParseConstList(ConstVector*); + Result ParseExpectedNan(ExpectedNan* expected); + Result ParseConstList(ConstVector*, ConstType type); Result ParseBlockInstr(std::unique_ptr<Expr>*); Result ParseLabelOpt(std::string*); Result ParseEndLabelOpt(const std::string&); @@ -187,8 +193,6 @@ class WastParser { Result ParseAssertMalformedCommand(CommandPtr*); Result ParseAssertReturnCommand(CommandPtr*); Result ParseAssertReturnFuncCommand(CommandPtr*); - Result ParseAssertReturnArithmeticNanCommand(CommandPtr*); - Result ParseAssertReturnCanonicalNanCommand(CommandPtr*); Result ParseAssertTrapCommand(CommandPtr*); Result ParseAssertUnlinkableCommand(CommandPtr*); Result ParseActionCommand(CommandPtr*); diff --git a/test/gen-spec-js.py b/test/gen-spec-js.py index b3f896f4..7e222781 100755 --- a/test/gen-spec-js.py +++ b/test/gen-spec-js.py @@ -165,14 +165,17 @@ def EscapeJSString(s): def IsValidJSConstant(const): type_ = const['type'] + value = const['value'] + if type_ in ('f32', 'f64') and value in ('nan:canonical', 'nan:arithmetic'): + return True if type_ == 'i32': return True elif type_ == 'i64': return False elif type_ == 'f32': - return not IsNaNF32(int(const['value'])) + return not IsNaNF32(int(value)) elif type_ == 'f64': - return not IsNaNF64(int(const['value'])) + return not IsNaNF64(int(value)) def IsValidJSAction(action): @@ -186,8 +189,7 @@ def IsValidJSCommand(command): expected = command['expected'] return (IsValidJSAction(action) and all(IsValidJSConstant(x) for x in expected)) - elif type_ in ('assert_return_canonical_nan', 'assert_return_arithmetic_nan', - 'assert_trap', 'assert_exhaustion'): + elif type_ in ('assert_trap', 'assert_exhaustion'): return IsValidJSAction(action) @@ -201,8 +203,7 @@ def CollectInvalidModuleCommands(commands): module_name = command.get('name') if module_name: module_map[module_name] = pair - elif command['type'] in ('assert_return', 'assert_return_canonical_nan', - 'assert_return_arithmetic_nan', 'assert_trap', + elif command['type'] in ('assert_return', 'assert_trap', 'assert_exhaustion'): if IsValidJSCommand(command): continue @@ -252,15 +253,16 @@ class ModuleExtender(object): self._Action(command['action']) for expected in command['expected']: self._Reinterpret(expected['type']) - self._Constant(expected) - self._Reinterpret(expected['type']) + if expected['value'] in ('nan:canonical', 'nan:arithmetic'): + self._NanBitmask(expected['value'] == 'nan:canonical', expected['type']) + self._And(expected['type']) + self._QuietNan(expected['type']) + else: + self._Constant(expected) + self._Reinterpret(expected['type']) self._Eq(expected['type']) self.lines.extend(['i32.eqz', 'br_if 0']) self.lines.extend(['return', 'end', 'unreachable', ')']) - elif command_type == 'assert_return_canonical_nan': - self._AssertReturnNan(new_field, command, True) - elif command_type == 'assert_return_arithmetic_nan': - self._AssertReturnNan(new_field, command, False) elif command_type in ('assert_trap', 'assert_exhaustion'): self.lines.append('(func (export "%s")' % new_field) self._Action(command['action']) @@ -273,22 +275,6 @@ class ModuleExtender(object): command['action']['args'] = [] command['expected'] = [] - def _AssertReturnNan(self, new_field, command, canonical): - type_ = command['expected'][0]['type'] - self.lines.append('(func (export "%s")' % new_field) - self.lines.append('block') - self._Action(command['action']) - self._Reinterpret(type_) - self._NanBitmask(canonical, type_) - self._And(type_) - self._QuietNan(type_) - self._Eq(type_) - self.lines.extend( - ['i32.eqz', 'br_if 0', 'return', 'end', 'unreachable', ')']) - - # Change the command to assert_return, it won't return NaN anymore. - command['type'] = 'assert_return' - def _GetExports(self, wat): result = {} pattern = r'^\s*\(export \"(.*?)\"\s*\((\w+) (\d+)' @@ -356,14 +342,16 @@ class ModuleExtender(object): def _Constant(self, const): inst = None type_ = const['type'] + value = const['value'] + assert value not in ('nan:canonical', 'nan:arithmetic') if type_ == 'i32': - inst = 'i32.const %s' % const['value'] + inst = 'i32.const %s' % value elif type_ == 'i64': - inst = 'i64.const %s' % const['value'] + inst = 'i64.const %s' % value elif type_ == 'f32': - inst = F32ToWasm(int(const['value'])) + inst = F32ToWasm(int(value)) elif type_ == 'f64': - inst = F64ToWasm(int(const['value'])) + inst = F64ToWasm(int(value)) self.lines.append(inst) def _RunWasm2Wat(self, wasm_path): @@ -403,8 +391,6 @@ class JSWriter(object): 'assert_unlinkable': self._WriteAssertModuleCommand, 'assert_uninstantiable': self._WriteAssertModuleCommand, 'assert_return': self._WriteAssertReturnCommand, - 'assert_return_canonical_nan': self._WriteAssertActionCommand, - 'assert_return_arithmetic_nan': self._WriteAssertActionCommand, 'assert_trap': self._WriteAssertActionCommand, 'assert_exhaustion': self._WriteAssertActionCommand, } @@ -463,13 +449,15 @@ class JSWriter(object): def _Constant(self, const): assert IsValidJSConstant(const), 'Invalid JS const: %s' % const type_ = const['type'] - value = int(const['value']) + value = const['value'] + if type_ in ('f32', 'f64') and value in ('nan:canonical', 'nan:arithmetic'): + return value if type_ == 'i32': - return I32ToJS(value) + return I32ToJS(int(value)) elif type_ == 'f32': - return F32ToJS(value) + return F32ToJS(int(value)) elif type_ == 'f64': - return F64ToJS(value) + return F64ToJS(int(value)) else: assert False diff --git a/test/gen-spec-js/assert_return_nan.txt b/test/gen-spec-js/assert_return_nan.txt index b1ed8d8f..e3770cca 100644 --- a/test/gen-spec-js/assert_return_nan.txt +++ b/test/gen-spec-js/assert_return_nan.txt @@ -9,16 +9,16 @@ (func (export "f64_nan_with_tag") (result f64) f64.const nan:0x1234) (func (export "f64_passthru") (param f64) (result f64) get_local 0)) -(assert_return_canonical_nan (invoke "f32_nan")) -(assert_return_arithmetic_nan (invoke "f32_nan_with_tag")) -(assert_return_canonical_nan (invoke "f64_nan")) -(assert_return_arithmetic_nan (invoke "f64_nan_with_tag")) +(assert_return (invoke "f32_nan") (f32.const nan:canonical)) +(assert_return (invoke "f32_nan_with_tag") (f32.const nan:arithmetic)) +(assert_return (invoke "f64_nan") (f64.const nan:canonical)) +(assert_return (invoke "f64_nan_with_tag") (f64.const nan:canonical)) ;; Rewritten to avoid passing nan as a parameter. -(assert_return_canonical_nan (invoke "f32_passthru" (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "f32_passthru" (f32.const nan:0x1234))) -(assert_return_canonical_nan (invoke "f64_passthru" (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "f64_passthru" (f64.const nan:0x1234))) +(assert_return (invoke "f32_passthru" (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "f32_passthru" (f32.const nan:0x1234)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64_passthru" (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64_passthru" (f64.const nan:0x1234)) (f64.const nan:arithmetic)) (;; STDOUT ;;; // A deliberately empty file for testing. @@ -27,16 +27,16 @@ let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x16\x05\x60\x00\x01\x7d\x60\x01\x7d\x01\x7d\x60\x00\x01\x7c\x60\x01\x7c\x01\x7c\x60\x00\x00\x03\x0b\x0a\x00\x00\x01\x02\x02\x03\x04\x04\x04\x04\x07\x85\x01\x0a\x07\x66\x33\x32\x5f\x6e\x61\x6e\x00\x00\x10\x66\x33\x32\x5f\x6e\x61\x6e\x5f\x77\x69\x74\x68\x5f\x74\x61\x67\x00\x01\x0c\x66\x33\x32\x5f\x70\x61\x73\x73\x74\x68\x72\x75\x00\x02\x07\x66\x36\x34\x5f\x6e\x61\x6e\x00\x03\x10\x66\x36\x34\x5f\x6e\x61\x6e\x5f\x77\x69\x74\x68\x5f\x74\x61\x67\x00\x04\x0c\x66\x36\x34\x5f\x70\x61\x73\x73\x74\x68\x72\x75\x00\x05\x08\x61\x73\x73\x65\x72\x74\x5f\x30\x00\x06\x08\x61\x73\x73\x65\x72\x74\x5f\x31\x00\x07\x08\x61\x73\x73\x65\x72\x74\x5f\x32\x00\x08\x08\x61\x73\x73\x65\x72\x74\x5f\x33\x00\x09\x0a\xd3\x01\x0a\x07\x00\x43\x00\x00\xc0\x7f\x0b\x07\x00\x43\x34\x12\x80\x7f\x0b\x04\x00\x20\x00\x0b\x0b\x00\x44\x00\x00\x00\x00\x00\x00\xf8\x7f\x0b\x0b\x00\x44\x34\x12\x00\x00\x00\x00\xf0\x7f\x0b\x04\x00\x20\x00\x0b\x20\x00\x02\x40\x43\x00\x00\xc0\xff\x10\x02\xbc\x41\xff\xff\xff\xff\x07\x71\x41\x80\x80\x80\xfe\x07\x46\x45\x0d\x00\x0f\x0b\x00\x0b\x20\x00\x02\x40\x43\x34\x12\x80\x7f\x10\x02\xbc\x41\x80\x80\x80\xfe\x07\x71\x41\x80\x80\x80\xfe\x07\x46\x45\x0d\x00\x0f\x0b\x00\x0b\x2e\x00\x02\x40\x44\x00\x00\x00\x00\x00\x00\xf8\xff\x10\x05\xbd\x42\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x83\x42\x80\x80\x80\x80\x80\x80\x80\xfc\xff\x00\x51\x45\x0d\x00\x0f\x0b\x00\x0b\x2e\x00\x02\x40\x44\x34\x12\x00\x00\x00\x00\xf0\x7f\x10\x05\xbd\x42\x80\x80\x80\x80\x80\x80\x80\xfc\xff\x00\x83\x42\x80\x80\x80\x80\x80\x80\x80\xfc\xff\x00\x51\x45\x0d\x00\x0f\x0b\x00\x0b"); // assert_return_nan.txt:12 -assert_return_canonical_nan(() => call($1, "f32_nan", [])); +assert_return(() => call($1, "f32_nan", []), nan:canonical); // assert_return_nan.txt:13 -assert_return_arithmetic_nan(() => call($1, "f32_nan_with_tag", [])); +assert_return(() => call($1, "f32_nan_with_tag", []), nan:arithmetic); // assert_return_nan.txt:14 -assert_return_canonical_nan(() => call($1, "f64_nan", [])); +assert_return(() => call($1, "f64_nan", []), nan:canonical); // assert_return_nan.txt:15 -assert_return_arithmetic_nan(() => call($1, "f64_nan_with_tag", [])); +assert_return(() => call($1, "f64_nan_with_tag", []), nan:canonical); // assert_return_nan.txt:18 assert_return(() => call($1, "assert_0", [])); diff --git a/test/interp/logging-all-opcodes.txt b/test/interp/logging-all-opcodes.txt index e5f4c36f..67402659 100644 --- a/test/interp/logging-all-opcodes.txt +++ b/test/interp/logging-all-opcodes.txt @@ -13027,8 +13027,8 @@ memory.init() => error: out of bounds memory access: memory.init out of bounds data.drop() => memory.copy() => memory.fill() => -table.init() => error: element segment dropped -elem.drop() => error: element segment dropped +table.init() => error: out of bounds table access: table.init out of bounds +elem.drop() => table.copy() => error: out of bounds table access: table.copy out of bounds v128.load() => v128.store() => diff --git a/test/interp/tracing-all-opcodes.txt b/test/interp/tracing-all-opcodes.txt index 0baf0fef..5a077122 100644 --- a/test/interp/tracing-all-opcodes.txt +++ b/test/interp/tracing-all-opcodes.txt @@ -1637,10 +1637,11 @@ memory.fill() => #0. 5136: V:1 | i32.const 2 #0. 5144: V:2 | i32.const 3 #0. 5152: V:3 | table.init $0, $0 -table.init() => error: element segment dropped +table.init() => error: out of bounds table access: table.init out of bounds >>> running export "elem.drop": #0. 5168: V:0 | elem.drop $0 -elem.drop() => error: element segment dropped +#0. 5176: V:0 | return +elem.drop() => >>> running export "table.copy": #0. 5180: V:0 | i32.const 1 #0. 5188: V:1 | i32.const 2 diff --git a/test/parse/assert/assert-return-arithmetic-nan.txt b/test/parse/assert/assert-return-arithmetic-nan.txt index ac185883..74ba2795 100644 --- a/test/parse/assert/assert-return-arithmetic-nan.txt +++ b/test/parse/assert/assert-return-arithmetic-nan.txt @@ -6,5 +6,4 @@ f32.div) (export "foo" (func $foo))) -(assert_return_arithmetic_nan - (invoke "foo" (f32.const 0))) +(assert_return (invoke "foo" (f32.const 0)) (f32.const nan:arithmetic)) diff --git a/test/parse/assert/assert-return-canonical-nan.txt b/test/parse/assert/assert-return-canonical-nan.txt index fc973f9c..69d08c42 100644 --- a/test/parse/assert/assert-return-canonical-nan.txt +++ b/test/parse/assert/assert-return-canonical-nan.txt @@ -6,5 +6,4 @@ f32.div) (export "foo" (func $foo))) -(assert_return_canonical_nan - (invoke "foo" (f32.const 0))) +(assert_return (invoke "foo" (f32.const 0)) (f32.const nan:canonical)) diff --git a/test/parse/assert/bad-assert-return-arithmetic-nan-invalid-return-type.txt b/test/parse/assert/bad-assert-return-arithmetic-nan-invalid-return-type.txt deleted file mode 100644 index 97b8ffae..00000000 --- a/test/parse/assert/bad-assert-return-arithmetic-nan-invalid-return-type.txt +++ /dev/null @@ -1,13 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module - (func $foo (result i32) - i32.const 0) - (export "foo" (func $foo))) - -(assert_return_arithmetic_nan (invoke "foo")) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-arithmetic-nan-invalid-return-type.txt:8:32: error: type mismatch at action. got i32, expected f32 or f64 -(assert_return_arithmetic_nan (invoke "foo")) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/parse/assert/bad-assert-return-arithmetic-nan-too-few.txt b/test/parse/assert/bad-assert-return-arithmetic-nan-too-few.txt deleted file mode 100644 index 498fe9e0..00000000 --- a/test/parse/assert/bad-assert-return-arithmetic-nan-too-few.txt +++ /dev/null @@ -1,12 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module - (func $foo (param i32) (result f32) - f32.const 0) - (export "foo" (func $foo))) -(assert_return_arithmetic_nan (invoke "foo")) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-arithmetic-nan-too-few.txt:7:32: error: too few parameters to function. got 0, expected 1 -(assert_return_arithmetic_nan (invoke "foo")) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/parse/assert/bad-assert-return-arithmetic-nan-too-many.txt b/test/parse/assert/bad-assert-return-arithmetic-nan-too-many.txt deleted file mode 100644 index c2e258f4..00000000 --- a/test/parse/assert/bad-assert-return-arithmetic-nan-too-many.txt +++ /dev/null @@ -1,12 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module - (func $foo (result f32) - f32.const 0) - (export "foo" (func $foo))) -(assert_return_arithmetic_nan (invoke "foo" (f32.const 0))) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-arithmetic-nan-too-many.txt:7:32: error: too many parameters to function. got 1, expected 0 -(assert_return_arithmetic_nan (invoke "foo" (f32.const 0))) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/parse/assert/bad-assert-return-arithmetic-nan-unknown-function.txt b/test/parse/assert/bad-assert-return-arithmetic-nan-unknown-function.txt deleted file mode 100644 index 24e371f3..00000000 --- a/test/parse/assert/bad-assert-return-arithmetic-nan-unknown-function.txt +++ /dev/null @@ -1,9 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module) -(assert_return_arithmetic_nan (invoke "foo")) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-arithmetic-nan-unknown-function.txt:4:32: error: unknown function export "foo" -(assert_return_arithmetic_nan (invoke "foo")) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/parse/assert/bad-assert-return-canonical-nan-invalid-return-type.txt b/test/parse/assert/bad-assert-return-canonical-nan-invalid-return-type.txt deleted file mode 100644 index 005c4ff6..00000000 --- a/test/parse/assert/bad-assert-return-canonical-nan-invalid-return-type.txt +++ /dev/null @@ -1,13 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module - (func $foo (result i32) - i32.const 0) - (export "foo" (func $foo))) - -(assert_return_canonical_nan (invoke "foo")) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-canonical-nan-invalid-return-type.txt:8:31: error: type mismatch at action. got i32, expected f32 or f64 -(assert_return_canonical_nan (invoke "foo")) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/parse/assert/bad-assert-return-canonical-nan-too-few.txt b/test/parse/assert/bad-assert-return-canonical-nan-too-few.txt deleted file mode 100644 index 73c40241..00000000 --- a/test/parse/assert/bad-assert-return-canonical-nan-too-few.txt +++ /dev/null @@ -1,12 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module - (func $foo (param i32) (result f32) - f32.const 0) - (export "foo" (func $foo))) -(assert_return_canonical_nan (invoke "foo")) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-canonical-nan-too-few.txt:7:31: error: too few parameters to function. got 0, expected 1 -(assert_return_canonical_nan (invoke "foo")) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/parse/assert/bad-assert-return-canonical-nan-too-many.txt b/test/parse/assert/bad-assert-return-canonical-nan-too-many.txt deleted file mode 100644 index acae9b3f..00000000 --- a/test/parse/assert/bad-assert-return-canonical-nan-too-many.txt +++ /dev/null @@ -1,12 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module - (func $foo (result f32) - f32.const 0) - (export "foo" (func $foo))) -(assert_return_canonical_nan (invoke "foo" (f32.const 0))) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-canonical-nan-too-many.txt:7:31: error: too many parameters to function. got 1, expected 0 -(assert_return_canonical_nan (invoke "foo" (f32.const 0))) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/parse/assert/bad-assert-return-canonical-nan-unknown-function.txt b/test/parse/assert/bad-assert-return-canonical-nan-unknown-function.txt deleted file mode 100644 index 0d614bc1..00000000 --- a/test/parse/assert/bad-assert-return-canonical-nan-unknown-function.txt +++ /dev/null @@ -1,9 +0,0 @@ -;;; TOOL: wast2json -;;; ERROR: 1 -(module) -(assert_return_canonical_nan (invoke "foo")) -(;; STDERR ;;; -out/test/parse/assert/bad-assert-return-canonical-nan-unknown-function.txt:4:31: error: unknown function export "foo" -(assert_return_canonical_nan (invoke "foo")) - ^^^^^^ -;;; STDERR ;;) diff --git a/test/run-spec-wasm2c.py b/test/run-spec-wasm2c.py index 01110621..4d33116e 100755 --- a/test/run-spec-wasm2c.py +++ b/test/run-spec-wasm2c.py @@ -196,8 +196,6 @@ class CWriter(object): 'assert_uninstantiable': self._WriteAssertUninstantiableCommand, 'action': self._WriteActionCommand, 'assert_return': self._WriteAssertReturnCommand, - 'assert_return_canonical_nan': self._WriteAssertReturnNanCommand, - 'assert_return_arithmetic_nan': self._WriteAssertReturnNanCommand, 'assert_trap': self._WriteAssertActionCommand, 'assert_exhaustion': self._WriteAssertActionCommand, } @@ -222,38 +220,40 @@ class CWriter(object): def _WriteAssertReturnCommand(self, command): expected = command['expected'] if len(expected) == 1: - assert_map = { - 'i32': 'ASSERT_RETURN_I32', - 'f32': 'ASSERT_RETURN_F32', - 'i64': 'ASSERT_RETURN_I64', - 'f64': 'ASSERT_RETURN_F64', - } - type_ = expected[0]['type'] - assert_macro = assert_map[type_] - self.out_file.write('%s(%s, %s);\n' % - (assert_macro, - self._Action(command), - self._ConstantList(expected))) + value = expected[0]['value'] + if value == 'nan:canonical': + assert_map = { + 'f32': 'ASSERT_RETURN_CANONICAL_NAN_F32', + 'f64': 'ASSERT_RETURN_CANONICAL_NAN_F64', + } + assert_macro = assert_map[(type_)] + self.out_file.write('%s(%s);\n' % (assert_macro, self._Action(command))) + elif value == 'nan:arithmetic': + assert_map = { + 'f32': 'ASSERT_RETURN_ARITHMETIC_NAN_F32', + 'f64': 'ASSERT_RETURN_ARITHMETIC_NAN_F64', + } + assert_macro = assert_map[(type_)] + self.out_file.write('%s(%s);\n' % (assert_macro, self._Action(command))) + else: + assert_map = { + 'i32': 'ASSERT_RETURN_I32', + 'f32': 'ASSERT_RETURN_F32', + 'i64': 'ASSERT_RETURN_I64', + 'f64': 'ASSERT_RETURN_F64', + } + + assert_macro = assert_map[type_] + self.out_file.write('%s(%s, %s);\n' % + (assert_macro, + self._Action(command), + self._ConstantList(expected))) elif len(expected) == 0: self._WriteAssertActionCommand(command) else: raise Error('Unexpected result with multiple values: %s' % expected) - def _WriteAssertReturnNanCommand(self, command): - assert_map = { - ('assert_return_canonical_nan', 'f32'): 'ASSERT_RETURN_CANONICAL_NAN_F32', - ('assert_return_canonical_nan', 'f64'): 'ASSERT_RETURN_CANONICAL_NAN_F64', - ('assert_return_arithmetic_nan', 'f32'): 'ASSERT_RETURN_ARITHMETIC_NAN_F32', - ('assert_return_arithmetic_nan', 'f64'): 'ASSERT_RETURN_ARITHMETIC_NAN_F64', - } - - expected = command['expected'] - type_ = expected[0]['type'] - assert_macro = assert_map[(command['type'], type_)] - - self.out_file.write('%s(%s);\n' % (assert_macro, self._Action(command))) - def _WriteAssertActionCommand(self, command): assert_map = { 'assert_exhaustion': 'ASSERT_EXHAUSTION', @@ -266,15 +266,17 @@ class CWriter(object): def _Constant(self, const): type_ = const['type'] - value = int(const['value']) + value = const['value'] + if type_ in ('f32', 'f64') and value in ('nan:canonical', 'nan:arithmetic'): + assert False if type_ == 'i32': - return '%su' % value + return '%su' % int(value) elif type_ == 'i64': - return '%sull' % value + return '%sull' % int(value) elif type_ == 'f32': - return F32ToC(value) + return F32ToC(int(value)) elif type_ == 'f64': - return F64ToC(value) + return F64ToC(int(value)) else: assert False diff --git a/test/spec/bulk-memory-operations/bulk.txt b/test/spec/bulk-memory-operations/bulk.txt index 8e615032..9ae4a80e 100644 --- a/test/spec/bulk-memory-operations/bulk.txt +++ b/test/spec/bulk-memory-operations/bulk.txt @@ -7,7 +7,7 @@ fill(i32:0, i32:48042, i32:2) => fill(i32:0, i32:0, i32:65536) => out/test/spec/bulk-memory-operations/bulk.wast:43: assert_trap passed: out of bounds memory access: memory.fill out of bounds fill(i32:65536, i32:0, i32:0) => -fill(i32:65537, i32:0, i32:0) => +out/test/spec/bulk-memory-operations/bulk.wast:52: assert_trap passed: out of bounds memory access: memory.fill out of bounds copy(i32:10, i32:0, i32:4) => copy(i32:8, i32:10, i32:4) => copy(i32:10, i32:7, i32:6) => @@ -15,36 +15,40 @@ copy(i32:65280, i32:0, i32:256) => copy(i32:65024, i32:65280, i32:256) => copy(i32:65536, i32:0, i32:0) => copy(i32:0, i32:65536, i32:0) => -copy(i32:65537, i32:0, i32:0) => -copy(i32:0, i32:65537, i32:0) => +out/test/spec/bulk-memory-operations/bulk.wast:108: assert_trap passed: out of bounds memory access: memory.copy out of bound +out/test/spec/bulk-memory-operations/bulk.wast:110: assert_trap passed: out of bounds memory access: memory.copy out of bound init(i32:0, i32:1, i32:2) => init(i32:65532, i32:0, i32:4) => -out/test/spec/bulk-memory-operations/bulk.wast:135: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/bulk.wast:138: assert_trap passed: out of bounds memory access: memory.init out of bounds init(i32:65536, i32:0, i32:0) => init(i32:0, i32:4, i32:0) => -init(i32:65537, i32:0, i32:0) => -init(i32:0, i32:5, i32:0) => +out/test/spec/bulk-memory-operations/bulk.wast:148: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/bulk.wast:150: assert_trap passed: out of bounds memory access: memory.init out of bounds init_passive(i32:1) => drop_passive() => -out/test/spec/bulk-memory-operations/bulk.wast:165: assert_trap passed: data segment dropped -out/test/spec/bulk-memory-operations/bulk.wast:167: assert_trap passed: data segment dropped -out/test/spec/bulk-memory-operations/bulk.wast:168: assert_trap passed: data segment dropped -out/test/spec/bulk-memory-operations/bulk.wast:170: assert_trap passed: data segment dropped -out/test/spec/bulk-memory-operations/bulk.wast:194: assert_trap passed: out of bounds table access: table.init out of bounds -out/test/spec/bulk-memory-operations/bulk.wast:196: assert_trap passed: uninitialized table element +drop_passive() => +out/test/spec/bulk-memory-operations/bulk.wast:172: assert_trap passed: out of bounds memory access: memory.init out of bounds +init_passive(i32:0) => +drop_active() => +out/test/spec/bulk-memory-operations/bulk.wast:176: assert_trap passed: out of bounds memory access: memory.init out of bounds +init_active(i32:0) => +out/test/spec/bulk-memory-operations/bulk.wast:201: assert_trap passed: out of bounds table access: table.init out of bounds +out/test/spec/bulk-memory-operations/bulk.wast:203: assert_trap passed: uninitialized table element init(i32:0, i32:1, i32:2) => -out/test/spec/bulk-memory-operations/bulk.wast:202: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/bulk.wast:209: assert_trap passed: uninitialized table element init(i32:1, i32:2, i32:2) => init(i32:3, i32:0, i32:0) => init(i32:0, i32:4, i32:0) => -init(i32:4, i32:0, i32:0) => -init(i32:0, i32:5, i32:0) => +out/test/spec/bulk-memory-operations/bulk.wast:219: assert_trap passed: out of bounds table access: table.init out of bounds +out/test/spec/bulk-memory-operations/bulk.wast:221: assert_trap passed: out of bounds table access: table.init out of bounds init_passive(i32:1) => drop_passive() => -out/test/spec/bulk-memory-operations/bulk.wast:236: assert_trap passed: element segment dropped -out/test/spec/bulk-memory-operations/bulk.wast:238: assert_trap passed: element segment dropped -out/test/spec/bulk-memory-operations/bulk.wast:239: assert_trap passed: element segment dropped -out/test/spec/bulk-memory-operations/bulk.wast:241: assert_trap passed: element segment dropped +drop_passive() => +out/test/spec/bulk-memory-operations/bulk.wast:247: assert_trap passed: out of bounds table access: table.init out of bounds +init_passive(i32:0) => +drop_active() => +out/test/spec/bulk-memory-operations/bulk.wast:251: assert_trap passed: out of bounds table access: table.init out of bounds +init_active(i32:0) => copy(i32:3, i32:0, i32:3) => copy(i32:0, i32:1, i32:3) => copy(i32:2, i32:0, i32:3) => @@ -52,7 +56,7 @@ copy(i32:6, i32:8, i32:2) => copy(i32:8, i32:6, i32:2) => copy(i32:10, i32:0, i32:0) => copy(i32:0, i32:10, i32:0) => -copy(i32:11, i32:0, i32:0) => -copy(i32:0, i32:11, i32:0) => -100/100 tests passed. +out/test/spec/bulk-memory-operations/bulk.wast:304: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/bulk.wast:306: assert_trap passed: out of bounds table access: table.copy out of bounds +104/104 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/bulk-memory-operations/data.txt b/test/spec/bulk-memory-operations/data.txt index 1b9f5004..7618122a 100644 --- a/test/spec/bulk-memory-operations/data.txt +++ b/test/spec/bulk-memory-operations/data.txt @@ -2,19 +2,17 @@ ;;; STDIN_FILE: third_party/testsuite/proposals/bulk-memory-operations/data.wast ;;; ARGS*: --enable-bulk-memory (;; STDOUT ;;; -error initializing module: out of bounds memory access: data segment is out of bounds: [1, 1) >= max value 0 -error initializing module: out of bounds memory access: data segment is out of bounds: [1, 1) >= max value 0 -out/test/spec/bulk-memory-operations/data.wast:290: assert_invalid passed: +out/test/spec/bulk-memory-operations/data.wast:293: assert_invalid passed: 000000e: error: data section without memory section -out/test/spec/bulk-memory-operations/data.wast:299: assert_invalid passed: +out/test/spec/bulk-memory-operations/data.wast:302: assert_invalid passed: 0000016: error: expected i32 init_expr -out/test/spec/bulk-memory-operations/data.wast:307: assert_invalid passed: +out/test/spec/bulk-memory-operations/data.wast:310: assert_invalid passed: 0000017: error: expected END opcode after initializer expression -out/test/spec/bulk-memory-operations/data.wast:315: assert_invalid passed: +out/test/spec/bulk-memory-operations/data.wast:318: assert_invalid passed: 0000015: error: unexpected opcode in initializer expression: 0x1 -out/test/spec/bulk-memory-operations/data.wast:323: assert_invalid passed: +out/test/spec/bulk-memory-operations/data.wast:326: assert_invalid passed: 0000015: error: unexpected opcode in initializer expression: 0x1 -out/test/spec/bulk-memory-operations/data.wast:331: assert_invalid passed: +out/test/spec/bulk-memory-operations/data.wast:334: assert_invalid passed: 0000017: error: expected END opcode after initializer expression -18/18 tests passed. +20/20 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/bulk-memory-operations/elem.txt b/test/spec/bulk-memory-operations/elem.txt index d04c65d6..b56ae0eb 100644 --- a/test/spec/bulk-memory-operations/elem.txt +++ b/test/spec/bulk-memory-operations/elem.txt @@ -2,19 +2,18 @@ ;;; STDIN_FILE: third_party/testsuite/proposals/bulk-memory-operations/elem.wast ;;; ARGS*: --enable-bulk-memory (;; STDOUT ;;; -error initializing module: out of bounds table access: elem segment is out of bounds: [1, 1) >= max value 0 -out/test/spec/bulk-memory-operations/elem.wast:299: assert_invalid passed: +out/test/spec/bulk-memory-operations/elem.wast:300: assert_invalid passed: 0000015: error: elem section without table section -out/test/spec/bulk-memory-operations/elem.wast:309: assert_invalid passed: +out/test/spec/bulk-memory-operations/elem.wast:310: assert_invalid passed: 0000014: error: expected i32 init_expr -out/test/spec/bulk-memory-operations/elem.wast:317: assert_invalid passed: +out/test/spec/bulk-memory-operations/elem.wast:318: assert_invalid passed: 0000015: error: expected END opcode after initializer expression -out/test/spec/bulk-memory-operations/elem.wast:325: assert_invalid passed: +out/test/spec/bulk-memory-operations/elem.wast:326: assert_invalid passed: 0000013: error: unexpected opcode in initializer expression: 0x1 -out/test/spec/bulk-memory-operations/elem.wast:333: assert_invalid passed: +out/test/spec/bulk-memory-operations/elem.wast:334: assert_invalid passed: 0000013: error: unexpected opcode in initializer expression: 0x1 -out/test/spec/bulk-memory-operations/elem.wast:341: assert_invalid passed: +out/test/spec/bulk-memory-operations/elem.wast:342: assert_invalid passed: 0000015: error: expected END opcode after initializer expression -out/test/spec/bulk-memory-operations/elem.wast:404: assert_trap passed: uninitialized table element -30/30 tests passed. +out/test/spec/bulk-memory-operations/elem.wast:405: assert_trap passed: uninitialized table element +31/31 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/bulk-memory-operations/memory_copy.txt b/test/spec/bulk-memory-operations/memory_copy.txt index fad932b3..dda46bb3 100644 --- a/test/spec/bulk-memory-operations/memory_copy.txt +++ b/test/spec/bulk-memory-operations/memory_copy.txt @@ -221,10 +221,11 @@ out/test/spec/bulk-memory-operations/memory_copy.wast:4830: assert_trap passed: out/test/spec/bulk-memory-operations/memory_copy.wast:4836: assert_trap passed: out of bounds memory access: memory.copy out of bound test() => test() => +out/test/spec/bulk-memory-operations/memory_copy.wast:4872: assert_trap passed: out of bounds memory access: memory.copy out of bound test() => +out/test/spec/bulk-memory-operations/memory_copy.wast:4884: assert_trap passed: out of bounds memory access: memory.copy out of bound test() => +out/test/spec/bulk-memory-operations/memory_copy.wast:4896: assert_trap passed: out of bounds memory access: memory.copy out of bound test() => -test() => -test() => -4416/4416 tests passed. +4417/4417 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/bulk-memory-operations/memory_fill.txt b/test/spec/bulk-memory-operations/memory_fill.txt index adc8bc27..d1da6801 100644 --- a/test/spec/bulk-memory-operations/memory_fill.txt +++ b/test/spec/bulk-memory-operations/memory_fill.txt @@ -7,7 +7,7 @@ out/test/spec/bulk-memory-operations/memory_fill.wast:43: assert_trap passed: ou out/test/spec/bulk-memory-operations/memory_fill.wast:61: assert_trap passed: out of bounds memory access: memory.fill out of bounds test() => test() => -test() => +out/test/spec/bulk-memory-operations/memory_fill.wast:117: assert_trap passed: out of bounds memory access: memory.fill out of bounds test() => test() => out/test/spec/bulk-memory-operations/memory_fill.wast:174: assert_invalid passed: diff --git a/test/spec/bulk-memory-operations/memory_init.txt b/test/spec/bulk-memory-operations/memory_init.txt index 2e138d71..61d459a8 100644 --- a/test/spec/bulk-memory-operations/memory_init.txt +++ b/test/spec/bulk-memory-operations/memory_init.txt @@ -12,9 +12,9 @@ out/test/spec/bulk-memory-operations/memory_init.wast:189: assert_invalid passed out/test/spec/bulk-memory-operations/memory_init.wast:195: assert_invalid passed: error: invalid data_segment_index: 4 (max 1) 000002c: error: OnDataDropExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:208: assert_trap passed: data segment dropped -out/test/spec/bulk-memory-operations/memory_init.wast:216: assert_trap passed: data segment dropped -out/test/spec/bulk-memory-operations/memory_init.wast:223: assert_trap passed: data segment dropped +test() => +out/test/spec/bulk-memory-operations/memory_init.wast:216: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:223: assert_trap passed: out of bounds memory access: memory.init out of bounds out/test/spec/bulk-memory-operations/memory_init.wast:226: assert_invalid passed: error: memory.init requires an imported or defined memory. 000002f: error: OnMemoryInitExpr callback failed @@ -25,205 +25,206 @@ test() => out/test/spec/bulk-memory-operations/memory_init.wast:252: assert_trap passed: out of bounds memory access: memory.init out of bounds out/test/spec/bulk-memory-operations/memory_init.wast:259: assert_trap passed: out of bounds memory access: memory.init out of bounds out/test/spec/bulk-memory-operations/memory_init.wast:266: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:273: assert_trap passed: out of bounds memory access: memory.init out of bounds test() => +out/test/spec/bulk-memory-operations/memory_init.wast:287: assert_trap passed: out of bounds memory access: memory.init out of bounds test() => test() => -test() => -test() => -out/test/spec/bulk-memory-operations/memory_init.wast:304: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:308: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:311: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, i32, f32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:312: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:319: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, i32, i64] 0000033: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:320: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:327: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, i32, f64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:328: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:335: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f32, i32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:336: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:343: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f32, f32] 0000039: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:344: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:351: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f32, i64] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:352: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:359: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f32, f64] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:360: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:367: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, i64, i32] 0000033: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:368: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:375: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, i64, f32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:376: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:383: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, i64, i64] 0000033: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:384: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:391: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, i64, f64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:392: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:399: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f64, i32] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:400: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:407: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f64, f32] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:408: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:415: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f64, i64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:416: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:423: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i32, f64, f64] 0000041: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:424: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:431: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i32, i32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:432: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:439: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i32, f32] 0000039: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:440: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:447: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i32, i64] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:448: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:455: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i32, f64] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:456: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:463: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f32, i32] 0000039: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:464: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:471: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f32, f32] 000003c: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:472: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:479: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f32, i64] 0000039: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:480: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:487: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f32, f64] 0000040: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:488: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:495: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i64, i32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:496: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:503: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i64, f32] 0000039: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:504: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:511: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i64, i64] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:512: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:519: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, i64, f64] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:520: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:527: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f64, i32] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:528: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:535: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f64, f32] 0000040: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:536: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:543: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f64, i64] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:544: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:551: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f32, f64, f64] 0000044: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:552: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:559: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i32, i32] 0000033: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:560: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:567: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i32, f32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:568: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:575: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i32, i64] 0000033: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:576: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:583: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i32, f64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:584: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:591: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f32, i32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:592: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:599: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f32, f32] 0000039: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:600: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:607: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f32, i64] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:608: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:615: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f32, f64] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:616: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:623: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i64, i32] 0000033: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:624: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:631: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i64, f32] 0000036: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:632: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:639: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i64, i64] 0000033: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:640: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:647: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, i64, f64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:648: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:655: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f64, i32] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:656: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:663: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f64, f32] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:664: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:671: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f64, i64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:672: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:679: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [i64, f64, f64] 0000041: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:680: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:687: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i32, i32] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:688: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:695: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i32, f32] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:696: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:703: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i32, i64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:704: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:711: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i32, f64] 0000041: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:712: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:719: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f32, i32] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:720: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:727: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f32, f32] 0000040: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:728: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:735: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f32, i64] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:736: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:743: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f32, f64] 0000044: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:744: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:751: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i64, i32] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:752: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:759: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i64, f32] 000003d: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:760: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:767: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i64, i64] 000003a: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:768: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:775: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, i64, f64] 0000041: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:776: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:783: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f64, i32] 0000041: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:784: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:791: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f64, f32] 0000044: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:792: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:799: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f64, i64] 0000041: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:800: assert_invalid passed: +out/test/spec/bulk-memory-operations/memory_init.wast:807: assert_invalid passed: error: type mismatch in memory.init, expected [i32, i32, i32] but got [f64, f64, f64] 0000048: error: OnMemoryInitExpr callback failed -out/test/spec/bulk-memory-operations/memory_init.wast:825: assert_trap passed: out of bounds memory access: memory.init out of bounds -out/test/spec/bulk-memory-operations/memory_init.wast:848: assert_trap passed: out of bounds memory access: memory.init out of bounds -out/test/spec/bulk-memory-operations/memory_init.wast:871: assert_trap passed: out of bounds memory access: memory.init out of bounds -out/test/spec/bulk-memory-operations/memory_init.wast:894: assert_trap passed: out of bounds memory access: memory.init out of bounds -out/test/spec/bulk-memory-operations/memory_init.wast:917: assert_trap passed: out of bounds memory access: memory.init out of bounds -out/test/spec/bulk-memory-operations/memory_init.wast:940: assert_trap passed: out of bounds memory access: memory.init out of bounds -215/215 tests passed. +out/test/spec/bulk-memory-operations/memory_init.wast:832: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:855: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:878: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:901: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:924: assert_trap passed: out of bounds memory access: memory.init out of bounds +out/test/spec/bulk-memory-operations/memory_init.wast:947: assert_trap passed: out of bounds memory access: memory.init out of bounds +216/216 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/bulk-memory-operations/table_copy.txt b/test/spec/bulk-memory-operations/table_copy.txt index 452f7657..734cd9e5 100644 --- a/test/spec/bulk-memory-operations/table_copy.txt +++ b/test/spec/bulk-memory-operations/table_copy.txt @@ -183,125 +183,110 @@ out/test/spec/bulk-memory-operations/table_copy.wast:540: assert_trap passed: ou out/test/spec/bulk-memory-operations/table_copy.wast:564: assert_trap passed: out of bounds table access: table.copy out of bounds test() => test() => +out/test/spec/bulk-memory-operations/table_copy.wast:636: assert_trap passed: out of bounds table access: table.copy out of bounds test() => +out/test/spec/bulk-memory-operations/table_copy.wast:684: assert_trap passed: out of bounds table access: table.copy out of bounds test() => -test() => -test() => -out/test/spec/bulk-memory-operations/table_copy.wast:736: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:746: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:747: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:748: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:749: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:750: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:751: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:752: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:753: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:754: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:755: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:756: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:757: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:758: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:759: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:760: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:761: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:762: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:763: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:764: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:765: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:766: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:767: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:768: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:769: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:797: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:808: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:809: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:810: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:811: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:812: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:813: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:814: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:815: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:816: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:817: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:818: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:819: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:820: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:821: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:822: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:823: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:824: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:825: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:826: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:827: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:828: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:829: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:830: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:858: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:860: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:861: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:862: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:863: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:864: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:865: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:866: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:867: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:868: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:869: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:870: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:871: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:872: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:873: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:874: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:875: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:876: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:877: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:878: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:879: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:880: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:881: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:882: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:883: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:919: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:921: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:922: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:923: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:924: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:925: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:926: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:927: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:928: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:929: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:930: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:931: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:932: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:933: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:934: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:935: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:936: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:937: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:938: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:939: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:940: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:941: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:942: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:943: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:980: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:982: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:983: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:984: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:985: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:986: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:987: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:988: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:989: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:990: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:991: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:992: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1001: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1002: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1003: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1004: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1005: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:732: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:760: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:770: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:771: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:772: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:773: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:774: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:775: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:776: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:777: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:778: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:779: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:780: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:781: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:782: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:783: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:784: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:785: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:786: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:787: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:788: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:789: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:790: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:791: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:792: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:793: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:821: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:832: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:833: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:834: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:835: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:836: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:837: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:838: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:839: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:840: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:841: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:842: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:843: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:844: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:845: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:846: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:847: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:848: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:849: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:850: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:851: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:852: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:853: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:854: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:882: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:884: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:885: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:886: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:887: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:888: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:889: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:890: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:891: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:892: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:893: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:894: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:895: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:896: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:897: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:898: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:899: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:900: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:901: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:902: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:903: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:904: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:905: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:906: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:907: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:943: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:945: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:946: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:947: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:948: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:949: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:950: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:951: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:952: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:953: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:954: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:955: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:956: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:957: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:958: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:959: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:960: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:961: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:962: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:963: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:964: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:965: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:966: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:967: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1004: assert_trap passed: out of bounds table access: table.copy out of bounds out/test/spec/bulk-memory-operations/table_copy.wast:1006: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1007: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1008: assert_trap passed: uninitialized table element @@ -310,128 +295,120 @@ out/test/spec/bulk-memory-operations/table_copy.wast:1010: assert_trap passed: u out/test/spec/bulk-memory-operations/table_copy.wast:1011: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1012: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1013: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1041: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:1043: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1044: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1045: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1046: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1047: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1048: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1049: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1050: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1051: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1052: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1053: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1054: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1055: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1056: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1057: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1058: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1059: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1060: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1061: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1062: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1063: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1064: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1065: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1066: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1102: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:1104: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1105: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1106: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1107: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1108: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1109: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1110: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1111: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1112: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1113: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1114: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1115: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1116: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1117: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1118: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1119: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1120: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1121: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1122: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1123: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1124: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1014: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1015: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1016: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1025: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1026: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1027: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1028: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1029: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1030: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1031: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1032: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1033: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1034: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1035: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1036: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1037: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1065: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:1067: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1068: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1069: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1070: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1071: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1072: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1073: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1074: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1075: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1076: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1077: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1078: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1079: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1080: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1081: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1082: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1083: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1084: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1085: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1086: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1087: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1088: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1089: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1090: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1126: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:1128: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1129: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1130: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1131: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1132: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1133: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1134: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1135: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1163: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:1165: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1166: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1167: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1168: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1169: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1170: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1171: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1172: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1173: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1174: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1175: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1176: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1177: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1178: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1179: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1180: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1181: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1182: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1183: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1184: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1185: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1186: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1187: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1188: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1224: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:1226: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1227: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1228: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1229: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1230: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1231: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1232: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1233: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1234: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1235: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1236: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1237: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1238: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1239: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1240: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1241: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1242: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1243: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1244: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1245: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1246: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1285: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:1287: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1288: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1289: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1290: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1291: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1292: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1293: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1294: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1295: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1296: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1297: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1298: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1299: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1300: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1301: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1302: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1303: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1304: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1305: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1306: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1307: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1308: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1309: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1310: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1136: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1137: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1138: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1139: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1140: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1141: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1142: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1143: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1144: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1145: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1146: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1147: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1148: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1157: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1158: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1159: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1187: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:1189: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1190: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1191: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1192: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1193: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1194: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1195: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1196: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1197: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1198: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1199: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1200: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1201: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1202: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1203: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1204: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1205: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1206: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1207: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1208: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1209: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1210: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1211: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1212: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1248: assert_trap passed: out of bounds table access: table.copy out of bounds +out/test/spec/bulk-memory-operations/table_copy.wast:1250: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1251: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1252: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1253: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1254: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1255: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1256: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1257: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1258: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1259: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1260: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1261: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1262: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1263: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1264: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1265: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1266: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1267: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1268: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1269: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1270: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1309: assert_trap passed: out of bounds table access: table.copy out of bounds out/test/spec/bulk-memory-operations/table_copy.wast:1311: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1312: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1313: assert_trap passed: uninitialized table element @@ -520,31 +497,31 @@ out/test/spec/bulk-memory-operations/table_copy.wast:1395: assert_trap passed: u out/test/spec/bulk-memory-operations/table_copy.wast:1396: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1397: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1398: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1442: assert_trap passed: out of bounds table access: table.copy out of bounds -out/test/spec/bulk-memory-operations/table_copy.wast:1460: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1461: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1462: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1463: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1464: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1465: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1466: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1467: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1468: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1469: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1470: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1471: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1472: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1473: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1474: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1475: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1476: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1477: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1478: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1479: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1480: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1481: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1482: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_copy.wast:1483: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1399: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1400: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1401: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1402: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1403: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1404: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1405: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1406: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1407: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1408: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1409: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1410: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1411: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1412: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1413: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1414: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1415: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1416: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1417: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1418: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1419: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1420: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1421: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1422: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1466: assert_trap passed: out of bounds table access: table.copy out of bounds out/test/spec/bulk-memory-operations/table_copy.wast:1484: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1485: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1486: assert_trap passed: uninitialized table element @@ -633,5 +610,29 @@ out/test/spec/bulk-memory-operations/table_copy.wast:1568: assert_trap passed: u out/test/spec/bulk-memory-operations/table_copy.wast:1569: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1570: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_copy.wast:1571: assert_trap passed: uninitialized table element -813/813 tests passed. +out/test/spec/bulk-memory-operations/table_copy.wast:1572: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1573: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1574: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1575: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1576: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1577: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1578: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1579: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1580: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1581: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1582: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1583: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1584: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1585: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1586: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1587: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1588: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1589: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1590: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1591: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1592: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1593: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1594: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_copy.wast:1595: assert_trap passed: uninitialized table element +814/814 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/bulk-memory-operations/table_init.txt b/test/spec/bulk-memory-operations/table_init.txt index 844edda5..50111408 100644 --- a/test/spec/bulk-memory-operations/table_init.txt +++ b/test/spec/bulk-memory-operations/table_init.txt @@ -65,232 +65,210 @@ out/test/spec/bulk-memory-operations/table_init.wast:205: assert_invalid passed: 0000024: error: elem section without table section out/test/spec/bulk-memory-operations/table_init.wast:213: assert_invalid passed: 0000024: error: elem section without table section -out/test/spec/bulk-memory-operations/table_init.wast:242: assert_trap passed: element segment dropped -out/test/spec/bulk-memory-operations/table_init.wast:265: assert_trap passed: element segment dropped test() => -out/test/spec/bulk-memory-operations/table_init.wast:311: assert_trap passed: element segment dropped -out/test/spec/bulk-memory-operations/table_init.wast:334: assert_trap passed: element segment dropped +out/test/spec/bulk-memory-operations/table_init.wast:265: assert_trap passed: out of bounds table access: table.init out of bounds +test() => +test() => +out/test/spec/bulk-memory-operations/table_init.wast:334: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:357: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:380: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:403: assert_trap passed: out of bounds table access: table.init out of bounds test() => +out/test/spec/bulk-memory-operations/table_init.wast:449: assert_trap passed: out of bounds table access: table.init out of bounds test() => +out/test/spec/bulk-memory-operations/table_init.wast:495: assert_trap passed: out of bounds table access: table.init out of bounds test() => -test() => -test() => -out/test/spec/bulk-memory-operations/table_init.wast:521: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:541: assert_trap passed: out of bounds table access: table.init out of bounds +out/test/spec/bulk-memory-operations/table_init.wast:544: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, i32, f32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:530: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:553: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, i32, i64] 0000041: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:539: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:562: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, i32, f64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:548: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:571: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f32, i32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:557: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:580: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f32, f32] 0000047: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:566: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:589: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f32, i64] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:575: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:598: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f32, f64] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:584: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:607: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, i64, i32] 0000041: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:593: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:616: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, i64, f32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:602: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:625: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, i64, i64] 0000041: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:611: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:634: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, i64, f64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:620: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:643: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f64, i32] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:629: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:652: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f64, f32] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:638: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:661: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f64, i64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:647: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:670: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i32, f64, f64] 000004f: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:656: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:679: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i32, i32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:665: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:688: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i32, f32] 0000047: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:674: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:697: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i32, i64] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:683: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:706: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i32, f64] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:692: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:715: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f32, i32] 0000047: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:701: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:724: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f32, f32] 000004a: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:710: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:733: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f32, i64] 0000047: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:719: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:742: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f32, f64] 000004e: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:728: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:751: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i64, i32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:737: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:760: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i64, f32] 0000047: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:746: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:769: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i64, i64] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:755: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:778: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, i64, f64] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:764: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:787: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f64, i32] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:773: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:796: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f64, f32] 000004e: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:782: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:805: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f64, i64] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:791: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:814: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f32, f64, f64] 0000052: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:800: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:823: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i32, i32] 0000041: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:809: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:832: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i32, f32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:818: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:841: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i32, i64] 0000041: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:827: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:850: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i32, f64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:836: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:859: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f32, i32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:845: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:868: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f32, f32] 0000047: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:854: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:877: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f32, i64] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:863: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:886: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f32, f64] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:872: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:895: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i64, i32] 0000041: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:881: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:904: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i64, f32] 0000044: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:890: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:913: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i64, i64] 0000041: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:899: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:922: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, i64, f64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:908: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:931: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f64, i32] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:917: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:940: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f64, f32] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:926: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:949: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f64, i64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:935: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:958: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [i64, f64, f64] 000004f: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:944: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:967: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i32, i32] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:953: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:976: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i32, f32] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:962: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:985: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i32, i64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:971: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:994: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i32, f64] 000004f: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:980: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1003: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f32, i32] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:989: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1012: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f32, f32] 000004e: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:998: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1021: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f32, i64] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1007: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1030: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f32, f64] 0000052: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1016: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1039: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i64, i32] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1025: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1048: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i64, f32] 000004b: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1034: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1057: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i64, i64] 0000048: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1043: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1066: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, i64, f64] 000004f: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1052: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1075: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f64, i32] 000004f: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1061: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1084: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f64, f32] 0000052: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1070: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1093: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f64, i64] 000004f: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1079: assert_invalid passed: +out/test/spec/bulk-memory-operations/table_init.wast:1102: assert_invalid passed: error: type mismatch in table.init, expected [i32, i32, i32] but got [f64, f64, f64] 0000056: error: OnTableInitExpr callback failed -out/test/spec/bulk-memory-operations/table_init.wast:1115: assert_trap passed: out of bounds table access: table.init out of bounds -out/test/spec/bulk-memory-operations/table_init.wast:1116: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1117: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1118: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1119: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1120: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1121: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1122: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1123: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1124: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1125: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1126: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1127: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1128: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1129: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1130: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1131: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1132: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1133: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1134: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1135: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1136: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1137: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1138: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1138: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:1139: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1140: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1141: assert_trap passed: uninitialized table element @@ -300,30 +278,30 @@ out/test/spec/bulk-memory-operations/table_init.wast:1144: assert_trap passed: u out/test/spec/bulk-memory-operations/table_init.wast:1145: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1146: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1147: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1177: assert_trap passed: out of bounds table access: table.init out of bounds -out/test/spec/bulk-memory-operations/table_init.wast:1178: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1179: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1180: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1181: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1182: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1183: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1184: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1185: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1186: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1187: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1188: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1189: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1190: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1191: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1192: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1193: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1194: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1195: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1196: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1197: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1198: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1199: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1200: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1148: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1149: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1150: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1151: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1152: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1153: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1154: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1155: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1156: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1157: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1158: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1159: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1160: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1161: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1162: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1163: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1164: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1165: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1166: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1167: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1168: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1169: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1170: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1200: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:1201: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1202: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1203: assert_trap passed: uninitialized table element @@ -333,30 +311,30 @@ out/test/spec/bulk-memory-operations/table_init.wast:1206: assert_trap passed: u out/test/spec/bulk-memory-operations/table_init.wast:1207: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1208: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1209: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1239: assert_trap passed: out of bounds table access: table.init out of bounds -out/test/spec/bulk-memory-operations/table_init.wast:1240: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1241: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1242: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1243: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1244: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1245: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1246: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1247: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1248: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1249: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1250: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1251: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1252: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1253: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1254: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1255: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1256: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1257: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1258: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1259: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1260: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1261: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1262: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1210: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1211: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1212: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1213: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1214: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1215: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1216: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1217: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1218: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1219: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1220: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1221: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1222: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1223: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1224: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1225: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1226: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1227: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1228: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1229: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1230: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1231: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1232: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1262: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:1263: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1264: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1265: assert_trap passed: uninitialized table element @@ -494,30 +472,30 @@ out/test/spec/bulk-memory-operations/table_init.wast:1396: assert_trap passed: u out/test/spec/bulk-memory-operations/table_init.wast:1397: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1398: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1399: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1429: assert_trap passed: out of bounds table access: table.init out of bounds -out/test/spec/bulk-memory-operations/table_init.wast:1430: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1431: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1432: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1433: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1434: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1435: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1436: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1437: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1438: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1439: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1440: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1441: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1442: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1443: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1444: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1445: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1446: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1447: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1448: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1449: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1450: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1451: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1452: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1400: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1401: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1402: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1403: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1404: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1405: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1406: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1407: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1408: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1409: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1410: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1411: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1412: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1413: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1414: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1415: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1416: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1417: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1418: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1419: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1420: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1421: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1422: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1452: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:1453: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1454: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1455: assert_trap passed: uninitialized table element @@ -655,30 +633,30 @@ out/test/spec/bulk-memory-operations/table_init.wast:1586: assert_trap passed: u out/test/spec/bulk-memory-operations/table_init.wast:1587: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1588: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1589: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1619: assert_trap passed: out of bounds table access: table.init out of bounds -out/test/spec/bulk-memory-operations/table_init.wast:1620: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1621: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1622: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1623: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1624: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1625: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1626: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1627: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1628: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1629: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1630: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1631: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1632: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1633: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1634: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1635: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1636: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1637: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1638: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1639: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1640: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1641: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1642: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1590: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1591: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1592: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1593: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1594: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1595: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1596: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1597: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1598: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1599: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1600: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1601: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1602: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1603: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1604: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1605: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1606: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1607: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1608: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1609: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1610: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1611: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1612: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1642: assert_trap passed: out of bounds table access: table.init out of bounds out/test/spec/bulk-memory-operations/table_init.wast:1643: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1644: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1645: assert_trap passed: uninitialized table element @@ -720,22 +698,45 @@ out/test/spec/bulk-memory-operations/table_init.wast:1680: assert_trap passed: u out/test/spec/bulk-memory-operations/table_init.wast:1681: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1682: assert_trap passed: uninitialized table element out/test/spec/bulk-memory-operations/table_init.wast:1683: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1713: assert_trap passed: out of bounds table access: table.init out of bounds -out/test/spec/bulk-memory-operations/table_init.wast:1714: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1715: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1716: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1717: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1718: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1719: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1720: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1721: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1722: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1723: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1724: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1725: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1726: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1727: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1728: assert_trap passed: uninitialized table element -out/test/spec/bulk-memory-operations/table_init.wast:1729: assert_trap passed: uninitialized table element -643/643 tests passed. +out/test/spec/bulk-memory-operations/table_init.wast:1684: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1685: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1686: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1687: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1688: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1689: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1690: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1691: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1692: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1693: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1694: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1695: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1696: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1697: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1698: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1699: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1700: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1701: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1702: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1703: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1704: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1705: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1706: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1736: assert_trap passed: out of bounds table access: table.init out of bounds +out/test/spec/bulk-memory-operations/table_init.wast:1737: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1738: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1739: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1740: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1741: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1742: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1743: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1744: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1745: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1746: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1747: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1748: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1749: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1750: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1751: assert_trap passed: uninitialized table element +out/test/spec/bulk-memory-operations/table_init.wast:1752: assert_trap passed: uninitialized table element +644/644 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/call.txt b/test/spec/call.txt index 6612a636..3b598e29 100644 --- a/test/spec/call.txt +++ b/test/spec/call.txt @@ -1,58 +1,58 @@ ;;; TOOL: run-interp-spec ;;; STDIN_FILE: third_party/testsuite/call.wast (;; STDOUT ;;; -out/test/spec/call.wast:289: assert_trap passed: undefined table index -out/test/spec/call.wast:314: assert_invalid passed: +out/test/spec/call.wast:299: assert_trap passed: undefined table index +out/test/spec/call.wast:326: assert_invalid passed: error: type mismatch in i32.eqz, expected [i32] but got [] 000001b: error: OnConvertExpr callback failed -out/test/spec/call.wast:321: assert_invalid passed: +out/test/spec/call.wast:333: assert_invalid passed: error: type mismatch in i32.eqz, expected [i32] but got [i64] 000001f: error: OnConvertExpr callback failed -out/test/spec/call.wast:329: assert_invalid passed: +out/test/spec/call.wast:341: assert_invalid passed: error: type mismatch in call, expected [i32] but got [] 000001e: error: OnCallExpr callback failed -out/test/spec/call.wast:336: assert_invalid passed: +out/test/spec/call.wast:348: assert_invalid passed: error: type mismatch in call, expected [f64, i32] but got [] 000001f: error: OnCallExpr callback failed -out/test/spec/call.wast:343: assert_invalid passed: +out/test/spec/call.wast:355: assert_invalid passed: error: type mismatch in function, expected [] but got [i32] 000001d: error: EndFunctionBody callback failed -out/test/spec/call.wast:350: assert_invalid passed: +out/test/spec/call.wast:362: assert_invalid passed: error: type mismatch in function, expected [] but got [f64, i32] 0000026: error: EndFunctionBody callback failed -out/test/spec/call.wast:358: assert_invalid passed: +out/test/spec/call.wast:370: assert_invalid passed: error: type mismatch in call, expected [i32, i32] but got [i32] 0000022: error: OnCallExpr callback failed -out/test/spec/call.wast:365: assert_invalid passed: +out/test/spec/call.wast:377: assert_invalid passed: error: type mismatch in call, expected [i32, i32] but got [i32] 0000022: error: OnCallExpr callback failed -out/test/spec/call.wast:372: assert_invalid passed: +out/test/spec/call.wast:384: assert_invalid passed: error: type mismatch in call, expected [i32, f64] but got [f64, i32] 000002a: error: OnCallExpr callback failed -out/test/spec/call.wast:379: assert_invalid passed: +out/test/spec/call.wast:391: assert_invalid passed: error: type mismatch in call, expected [f64, i32] but got [i32, f64] 000002a: error: OnCallExpr callback failed -out/test/spec/call.wast:387: assert_invalid passed: +out/test/spec/call.wast:399: assert_invalid passed: error: type mismatch in call, expected [i32] but got [] 0000020: error: OnCallExpr callback failed -out/test/spec/call.wast:396: assert_invalid passed: +out/test/spec/call.wast:408: assert_invalid passed: error: type mismatch in call, expected [i32, i32] but got [i32] 0000023: error: OnCallExpr callback failed -out/test/spec/call.wast:405: assert_invalid passed: +out/test/spec/call.wast:417: assert_invalid passed: error: type mismatch in call, expected [i32] but got [] 0000020: error: OnCallExpr callback failed -out/test/spec/call.wast:414: assert_invalid passed: +out/test/spec/call.wast:426: assert_invalid passed: error: type mismatch in call, expected [i32, i32] but got [i32] 0000023: error: OnCallExpr callback failed -out/test/spec/call.wast:423: assert_invalid passed: +out/test/spec/call.wast:435: assert_invalid passed: error: type mismatch in call, expected [i32] but got [] 0000022: error: OnCallExpr callback failed -out/test/spec/call.wast:432: assert_invalid passed: +out/test/spec/call.wast:444: assert_invalid passed: error: type mismatch in call, expected [i32, i32] but got [i32] 0000025: error: OnCallExpr callback failed -out/test/spec/call.wast:445: assert_invalid passed: +out/test/spec/call.wast:457: assert_invalid passed: 0000019: error: invalid call function index: 1 -out/test/spec/call.wast:449: assert_invalid passed: +out/test/spec/call.wast:461: assert_invalid passed: 000001d: error: invalid call function index: 1012321300 -81/81 tests passed. +82/82 tests passed. ;;; STDOUT ;;) diff --git a/test/spec/reference-types/table_fill.txt b/test/spec/reference-types/table_fill.txt index 9f898020..30a88ce9 100644 --- a/test/spec/reference-types/table_fill.txt +++ b/test/spec/reference-types/table_fill.txt @@ -2,9 +2,9 @@ ;;; STDIN_FILE: third_party/testsuite/proposals/reference-types/table_fill.wast ;;; ARGS*: --enable-reference-types (;; STDOUT ;;; -out/test/spec/reference-types/table_fill.wast:50: assert_trap passed: out of bounds memory access -out/test/spec/reference-types/table_fill.wast:58: assert_trap passed: out of bounds memory access -out/test/spec/reference-types/table_fill.wast:63: assert_trap passed: out of bounds memory access +out/test/spec/reference-types/table_fill.wast:50: assert_trap passed: out of bounds table access +out/test/spec/reference-types/table_fill.wast:58: assert_trap passed: out of bounds table access +out/test/spec/reference-types/table_fill.wast:63: assert_trap passed: out of bounds table access out/test/spec/reference-types/table_fill.wast:71: assert_invalid passed: error: type mismatch in table.fill, expected [i32, anyref, i32] but got [] 0000020: error: OnTableFillExpr callback failed diff --git a/test/spectest-interp-assert-failure.txt b/test/spectest-interp-assert-failure.txt new file mode 100644 index 00000000..03673cad --- /dev/null +++ b/test/spectest-interp-assert-failure.txt @@ -0,0 +1,20 @@ +;;; TOOL: run-interp-spec +;;; ERROR: 2 +;; spectest-interp returns the number of failed tests as the error code. +(module + (func (export "func32") (result f32) (f32.const 0.1)) + (func (export "func64") (result f64) (f64.const 0.2)) + (func (export "func32nan") (result f32) (f32.const nan)) + (func (export "func64nan") (result f64) (f64.const nan)) +) +(assert_return (invoke "func32") (f32.const nan:canonical)) +(assert_return (invoke "func64") (f64.const nan:arithmetic)) +(assert_return (invoke "func32nan") (f32.const nan:arithmetic)) +(assert_return (invoke "func64nan") (f64.const nan:arithmetic)) +(assert_return (invoke "func32nan") (f32.const nan:canonical)) +(assert_return (invoke "func64nan") (f64.const nan:canonical)) +(;; STDOUT ;;; +out/test/spectest-interp-assert-failure.txt:10: expected result to be nan, got f32:0.100000 +out/test/spectest-interp-assert-failure.txt:11: expected result to be nan, got f64:0.200000 +4/6 tests passed. +;;; STDOUT ;;) diff --git a/test/wasm2c/spec/call.txt b/test/wasm2c/spec/call.txt index d258328d..c6d9de4c 100644 --- a/test/wasm2c/spec/call.txt +++ b/test/wasm2c/spec/call.txt @@ -1,5 +1,5 @@ ;;; TOOL: run-spec-wasm2c ;;; STDIN_FILE: third_party/testsuite/call.wast (;; STDOUT ;;; -63/63 tests passed. +64/64 tests passed. ;;; STDOUT ;;) diff --git a/third_party/testsuite b/third_party/testsuite -Subproject 4e4ceb6ccbcd9ef39d464a9a6a61d94a7d57e7b +Subproject dfd21598aa86fc0b03b92eeb881ebb45171d169 |