| // Copyright 2015 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/wasm/function-body-decoder.h" |
| |
| #include "src/init/v8.h" |
| #include "src/objects/objects-inl.h" |
| #include "src/objects/objects.h" |
| #include "src/utils/ostreams.h" |
| #include "src/wasm/function-body-decoder-impl.h" |
| #include "src/wasm/leb-helper.h" |
| #include "src/wasm/local-decl-encoder.h" |
| #include "src/wasm/signature-map.h" |
| #include "src/wasm/wasm-limits.h" |
| #include "src/wasm/wasm-module.h" |
| #include "src/wasm/wasm-opcodes-inl.h" |
| #include "src/zone/zone.h" |
| #include "test/common/wasm/flag-utils.h" |
| #include "test/common/wasm/test-signatures.h" |
| #include "test/common/wasm/wasm-macro-gen.h" |
| #include "test/unittests/test-utils.h" |
| #include "testing/gmock-support.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace wasm { |
| namespace function_body_decoder_unittest { |
| |
| #define B1(a) WASM_BLOCK(a) |
| #define B2(a, b) WASM_BLOCK(a, b) |
| #define B3(a, b, c) WASM_BLOCK(a, b, c) |
| |
| #define WASM_IF_OP kExprIf, kVoidCode |
| #define WASM_LOOP_OP kExprLoop, kVoidCode |
| |
| #define EXPECT_OK(result) \ |
| do { \ |
| if (!result.ok()) { \ |
| GTEST_NONFATAL_FAILURE_(result.error().message().c_str()); \ |
| return; \ |
| } \ |
| } while (false) |
| |
| static const byte kCodeGetLocal0[] = {kExprLocalGet, 0}; |
| static const byte kCodeGetLocal1[] = {kExprLocalGet, 1}; |
| static const byte kCodeSetLocal0[] = {WASM_SET_LOCAL(0, WASM_ZERO)}; |
| static const byte kCodeTeeLocal0[] = {WASM_TEE_LOCAL(0, WASM_ZERO)}; |
| |
| static const ValueType kValueTypes[] = {kWasmI32, kWasmI64, kWasmF32, kWasmF64, |
| kWasmExternRef}; |
| static const MachineType machineTypes[] = { |
| MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(), |
| MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(), |
| MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(), |
| MachineType::Float64()}; |
| |
| static const WasmOpcode kInt32BinopOpcodes[] = { |
| kExprI32Add, kExprI32Sub, kExprI32Mul, kExprI32DivS, kExprI32DivU, |
| kExprI32RemS, kExprI32RemU, kExprI32And, kExprI32Ior, kExprI32Xor, |
| kExprI32Shl, kExprI32ShrU, kExprI32ShrS, kExprI32Eq, kExprI32LtS, |
| kExprI32LeS, kExprI32LtU, kExprI32LeU}; |
| |
| #define WASM_BRV_IF_ZERO(depth, val) \ |
| val, WASM_ZERO, kExprBrIf, static_cast<byte>(depth) |
| |
| constexpr size_t kMaxByteSizedLeb128 = 127; |
| |
| using F = std::pair<ValueType, bool>; |
| |
| enum MemoryType { kMemory32, kMemory64 }; |
| |
| // A helper for tests that require a module environment for functions, |
| // globals, or memories. |
| class TestModuleBuilder { |
| public: |
| explicit TestModuleBuilder(ModuleOrigin origin = kWasmOrigin) |
| : allocator(), mod(std::make_unique<Zone>(&allocator, ZONE_NAME)) { |
| mod.origin = origin; |
| } |
| byte AddGlobal(ValueType type, bool mutability = true) { |
| mod.globals.push_back( |
| {type, mutability, WasmInitExpr(), {0}, false, false}); |
| CHECK_LE(mod.globals.size(), kMaxByteSizedLeb128); |
| return static_cast<byte>(mod.globals.size() - 1); |
| } |
| byte AddSignature(const FunctionSig* sig) { |
| mod.add_signature(sig); |
| CHECK_LE(mod.types.size(), kMaxByteSizedLeb128); |
| return static_cast<byte>(mod.types.size() - 1); |
| } |
| byte AddFunction(const FunctionSig* sig, bool declared = true) { |
| byte sig_index = AddSignature(sig); |
| mod.functions.push_back( |
| {sig, // sig |
| static_cast<uint32_t>(mod.functions.size()), // func_index |
| sig_index, // sig_index |
| {0, 0}, // code |
| false, // import |
| false, // export |
| declared}); // declared |
| CHECK_LE(mod.functions.size(), kMaxByteSizedLeb128); |
| return static_cast<byte>(mod.functions.size() - 1); |
| } |
| byte AddImport(const FunctionSig* sig) { |
| byte result = AddFunction(sig); |
| mod.functions[result].imported = true; |
| return result; |
| } |
| byte AddException(WasmExceptionSig* sig) { |
| mod.exceptions.emplace_back(sig); |
| CHECK_LE(mod.types.size(), kMaxByteSizedLeb128); |
| return static_cast<byte>(mod.exceptions.size() - 1); |
| } |
| |
| byte AddTable(ValueType type, uint32_t initial_size, bool has_maximum_size, |
| uint32_t maximum_size) { |
| CHECK(WasmTable::IsValidTableType(type, &mod)); |
| mod.tables.emplace_back(); |
| WasmTable& table = mod.tables.back(); |
| table.type = type; |
| table.initial_size = initial_size; |
| table.has_maximum_size = has_maximum_size; |
| table.maximum_size = maximum_size; |
| return static_cast<byte>(mod.tables.size() - 1); |
| } |
| |
| byte AddStruct(std::initializer_list<F> fields) { |
| StructType::Builder type_builder(mod.signature_zone.get(), |
| static_cast<uint32_t>(fields.size())); |
| for (F field : fields) { |
| type_builder.AddField(field.first, field.second); |
| } |
| mod.add_struct_type(type_builder.Build()); |
| return static_cast<byte>(mod.type_kinds.size() - 1); |
| } |
| |
| byte AddArray(ValueType type, bool mutability) { |
| ArrayType* array = mod.signature_zone->New<ArrayType>(type, mutability); |
| mod.add_array_type(array); |
| return static_cast<byte>(mod.type_kinds.size() - 1); |
| } |
| |
| void InitializeMemory(MemoryType mem_type = kMemory32) { |
| mod.has_memory = true; |
| mod.is_memory64 = mem_type == kMemory64; |
| mod.initial_pages = 1; |
| mod.maximum_pages = 100; |
| } |
| |
| byte InitializeTable(wasm::ValueType type) { |
| mod.tables.emplace_back(); |
| mod.tables.back().type = type; |
| return static_cast<byte>(mod.tables.size() - 1); |
| } |
| |
| byte AddPassiveElementSegment(wasm::ValueType type) { |
| mod.elem_segments.emplace_back(false); |
| auto& init = mod.elem_segments.back(); |
| init.type = type; |
| // Add 5 empty elements. |
| for (uint32_t j = 0; j < 5; j++) { |
| init.entries.push_back(WasmElemSegment::kNullIndex); |
| } |
| return static_cast<byte>(mod.elem_segments.size() - 1); |
| } |
| |
| byte AddDeclarativeElementSegment() { |
| mod.elem_segments.emplace_back(true); |
| mod.elem_segments.back().entries.push_back(WasmElemSegment::kNullIndex); |
| return static_cast<byte>(mod.elem_segments.size() - 1); |
| } |
| |
| // Set the number of data segments as declared by the DataCount section. |
| void SetDataSegmentCount(uint32_t data_segment_count) { |
| // The Data section occurs after the Code section, so we don't need to |
| // update mod.data_segments, as it is always empty. |
| mod.num_declared_data_segments = data_segment_count; |
| } |
| |
| WasmModule* module() { return &mod; } |
| |
| private: |
| AccountingAllocator allocator; |
| WasmModule mod; |
| }; |
| |
| class FunctionBodyDecoderTest : public TestWithZone { |
| public: |
| using LocalsDecl = std::pair<uint32_t, ValueType>; |
| // All features are disabled by default and must be activated with |
| // a WASM_FEATURE_SCOPE in individual tests. |
| WasmFeatures enabled_features_ = WasmFeatures::None(); |
| |
| FunctionBodyDecoderTest() : local_decls(zone()) {} |
| |
| TestSignatures sigs; |
| TestModuleBuilder builder; |
| WasmModule* module = builder.module(); |
| LocalDeclEncoder local_decls; |
| |
| void AddLocals(ValueType type, uint32_t count) { |
| local_decls.AddLocals(count, type); |
| } |
| |
| enum AppendEnd : bool { kAppendEnd, kOmitEnd }; |
| |
| Vector<const byte> PrepareBytecode(Vector<const byte> code, |
| AppendEnd append_end) { |
| size_t locals_size = local_decls.Size(); |
| size_t total_size = |
| code.size() + locals_size + (append_end == kAppendEnd ? 1 : 0); |
| byte* buffer = zone()->NewArray<byte>(total_size); |
| // Prepend the local decls to the code. |
| local_decls.Emit(buffer); |
| // Emit the code. |
| if (code.size() > 0) { |
| memcpy(buffer + locals_size, code.begin(), code.size()); |
| } |
| if (append_end == kAppendEnd) { |
| // Append an extra end opcode. |
| buffer[total_size - 1] = kExprEnd; |
| } |
| |
| return {buffer, total_size}; |
| } |
| |
| template <size_t N> |
| Vector<const byte> CodeToVector(const byte (&code)[N]) { |
| return ArrayVector(code); |
| } |
| |
| Vector<const byte> CodeToVector( |
| const std::initializer_list<const byte>& code) { |
| return VectorOf(&*code.begin(), code.size()); |
| } |
| |
| Vector<const byte> CodeToVector(Vector<const byte> vec) { return vec; } |
| |
| // Prepends local variable declarations and renders nice error messages for |
| // verification failures. |
| template <typename Code = std::initializer_list<const byte>> |
| void Validate(bool expected_success, const FunctionSig* sig, Code&& raw_code, |
| AppendEnd append_end = kAppendEnd, |
| const char* message = nullptr) { |
| Vector<const byte> code = |
| PrepareBytecode(CodeToVector(std::forward<Code>(raw_code)), append_end); |
| |
| // Validate the code. |
| FunctionBody body(sig, 0, code.begin(), code.end()); |
| WasmFeatures unused_detected_features = WasmFeatures::None(); |
| DecodeResult result = |
| VerifyWasmCode(zone()->allocator(), enabled_features_, module, |
| &unused_detected_features, body); |
| |
| std::ostringstream str; |
| if (result.failed()) { |
| str << "Verification failed: pc = +" << result.error().offset() |
| << ", msg = " << result.error().message(); |
| } else { |
| str << "Verification succeeded, expected failure"; |
| } |
| EXPECT_EQ(result.ok(), expected_success) << str.str(); |
| if (result.failed() && message) { |
| EXPECT_THAT(result.error().message(), ::testing::HasSubstr(message)); |
| } |
| } |
| |
| template <typename Code = std::initializer_list<const byte>> |
| void ExpectValidates(const FunctionSig* sig, Code&& raw_code, |
| AppendEnd append_end = kAppendEnd, |
| const char* message = nullptr) { |
| Validate(true, sig, std::forward<Code>(raw_code), append_end, message); |
| } |
| |
| template <typename Code = std::initializer_list<const byte>> |
| void ExpectFailure(const FunctionSig* sig, Code&& raw_code, |
| AppendEnd append_end = kAppendEnd, |
| const char* message = nullptr) { |
| Validate(false, sig, std::forward<Code>(raw_code), append_end, message); |
| } |
| |
| void TestBinop(WasmOpcode opcode, const FunctionSig* success) { |
| // op(local[0], local[1]) |
| byte code[] = {WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))}; |
| ExpectValidates(success, code); |
| |
| // Try all combinations of return and parameter types. |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| for (size_t k = 0; k < arraysize(kValueTypes); k++) { |
| ValueType types[] = {kValueTypes[i], kValueTypes[j], kValueTypes[k]}; |
| if (types[0] != success->GetReturn(0) || |
| types[1] != success->GetParam(0) || |
| types[2] != success->GetParam(1)) { |
| // Test signature mismatch. |
| FunctionSig sig(1, 2, types); |
| ExpectFailure(&sig, code); |
| } |
| } |
| } |
| } |
| } |
| |
| void TestUnop(WasmOpcode opcode, const FunctionSig* success) { |
| TestUnop(opcode, success->GetReturn(), success->GetParam(0)); |
| } |
| |
| void TestUnop(WasmOpcode opcode, ValueType ret_type, ValueType param_type) { |
| // Return(op(local[0])) |
| byte code[] = {WASM_UNOP(opcode, WASM_GET_LOCAL(0))}; |
| { |
| ValueType types[] = {ret_type, param_type}; |
| FunctionSig sig(1, 1, types); |
| ExpectValidates(&sig, code); |
| } |
| |
| // Try all combinations of return and parameter types. |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| ValueType types[] = {kValueTypes[i], kValueTypes[j]}; |
| if (types[0] != ret_type || types[1] != param_type) { |
| // Test signature mismatch. |
| FunctionSig sig(1, 1, types); |
| ExpectFailure(&sig, code); |
| } |
| } |
| } |
| } |
| }; |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Const1) { |
| byte code[] = {kExprI32Const, 0}; |
| for (int i = -64; i <= 63; i++) { |
| code[1] = static_cast<byte>(i & 0x7F); |
| ExpectValidates(sigs.i_i(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, RefFunc) { |
| WASM_FEATURE_SCOPE(reftypes); |
| |
| builder.AddFunction(sigs.v_ii()); |
| builder.AddFunction(sigs.ii_v()); |
| ExpectValidates(sigs.a_v(), {kExprRefFunc, 1}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, EmptyFunction) { |
| ExpectValidates(sigs.v_v(), {}); |
| ExpectFailure(sigs.i_i(), {}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IncompleteIf1) { |
| byte code[] = {kExprIf}; |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Const_fallthru) { |
| ExpectValidates(sigs.i_i(), {WASM_I32V_1(0)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Const_fallthru2) { |
| ExpectFailure(sigs.i_i(), {WASM_I32V_1(0), WASM_I32V_1(1)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Const) { |
| const int kInc = 4498211; |
| for (int32_t i = kMinInt; i < kMaxInt - kInc; i = i + kInc) { |
| // TODO(binji): expand test for other sized int32s; 1 through 5 bytes. |
| ExpectValidates(sigs.i_i(), {WASM_I32V(i)}); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int64Const) { |
| const int kInc = 4498211; |
| for (int32_t i = kMinInt; i < kMaxInt - kInc; i = i + kInc) { |
| ExpectValidates(sigs.l_l(), |
| {WASM_I64V((static_cast<uint64_t>(i) << 32) | i)}); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Float32Const) { |
| byte code[] = {kExprF32Const, 0, 0, 0, 0}; |
| Address ptr = reinterpret_cast<Address>(code + 1); |
| for (int i = 0; i < 30; i++) { |
| base::WriteLittleEndianValue<float>(ptr, i * -7.75f); |
| ExpectValidates(sigs.f_ff(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Float64Const) { |
| byte code[] = {kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0}; |
| Address ptr = reinterpret_cast<Address>(code + 1); |
| for (int i = 0; i < 30; i++) { |
| base::WriteLittleEndianValue<double>(ptr, i * 33.45); |
| ExpectValidates(sigs.d_dd(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Const_off_end) { |
| byte code[] = {kExprI32Const, 0xAA, 0xBB, 0xCC, 0x44}; |
| |
| for (size_t size = 1; size <= 4; ++size) { |
| ExpectFailure(sigs.i_i(), VectorOf(code, size), kAppendEnd); |
| // Should also fail without the trailing 'end' opcode. |
| ExpectFailure(sigs.i_i(), VectorOf(code, size), kOmitEnd); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal0_param) { |
| ExpectValidates(sigs.i_i(), kCodeGetLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal0_local) { |
| AddLocals(kWasmI32, 1); |
| ExpectValidates(sigs.i_v(), kCodeGetLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, TooManyLocals) { |
| AddLocals(kWasmI32, 4034986500); |
| ExpectFailure(sigs.i_v(), kCodeGetLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal0_param_n) { |
| for (const FunctionSig* sig : {sigs.i_i(), sigs.i_ii(), sigs.i_iii()}) { |
| ExpectValidates(sig, kCodeGetLocal0); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocalN_local) { |
| for (byte i = 1; i < 8; i++) { |
| AddLocals(kWasmI32, 1); |
| for (byte j = 0; j < i; j++) { |
| ExpectValidates(sigs.i_v(), {kExprLocalGet, j}); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal0_fail_no_params) { |
| ExpectFailure(sigs.i_v(), kCodeGetLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal1_fail_no_locals) { |
| ExpectFailure(sigs.i_i(), kCodeGetLocal1); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal_off_end) { |
| ExpectFailure(sigs.i_i(), {kExprLocalGet}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, NumLocalBelowLimit) { |
| AddLocals(kWasmI32, kV8MaxWasmFunctionLocals - 1); |
| ExpectValidates(sigs.v_v(), {WASM_NOP}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, NumLocalAtLimit) { |
| AddLocals(kWasmI32, kV8MaxWasmFunctionLocals); |
| ExpectValidates(sigs.v_v(), {WASM_NOP}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, NumLocalAboveLimit) { |
| AddLocals(kWasmI32, kV8MaxWasmFunctionLocals + 1); |
| ExpectFailure(sigs.v_v(), {WASM_NOP}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal_varint) { |
| const int kMaxLocals = kV8MaxWasmFunctionLocals - 1; |
| AddLocals(kWasmI32, kMaxLocals); |
| |
| ExpectValidates(sigs.i_i(), {kExprLocalGet, U32V_1(66)}); |
| ExpectValidates(sigs.i_i(), {kExprLocalGet, U32V_2(7777)}); |
| ExpectValidates(sigs.i_i(), {kExprLocalGet, U32V_3(8888)}); |
| ExpectValidates(sigs.i_i(), {kExprLocalGet, U32V_4(9999)}); |
| |
| ExpectValidates(sigs.i_i(), {kExprLocalGet, U32V_5(kMaxLocals - 1)}); |
| |
| ExpectFailure(sigs.i_i(), {kExprLocalGet, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}); |
| |
| ExpectValidates(sigs.i_i(), {kExprLocalGet, U32V_4(kMaxLocals - 1)}); |
| ExpectValidates(sigs.i_i(), {kExprLocalGet, U32V_4(kMaxLocals)}); |
| ExpectFailure(sigs.i_i(), {kExprLocalGet, U32V_4(kMaxLocals + 1)}); |
| |
| ExpectFailure(sigs.i_v(), {kExprLocalGet, U32V_4(kMaxLocals)}); |
| ExpectFailure(sigs.i_v(), {kExprLocalGet, U32V_4(kMaxLocals + 1)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, GetLocal_toomany) { |
| AddLocals(kWasmI32, kV8MaxWasmFunctionLocals - 100); |
| AddLocals(kWasmI32, 100); |
| |
| ExpectValidates(sigs.i_v(), {kExprLocalGet, U32V_1(66)}); |
| ExpectFailure(sigs.i_i(), {kExprLocalGet, U32V_1(66)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Binops_off_end) { |
| byte code1[] = {0}; // [opcode] |
| for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) { |
| code1[0] = kInt32BinopOpcodes[i]; |
| ExpectFailure(sigs.i_i(), code1); |
| } |
| |
| byte code3[] = {kExprLocalGet, 0, 0}; // [expr] [opcode] |
| for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) { |
| code3[2] = kInt32BinopOpcodes[i]; |
| ExpectFailure(sigs.i_i(), code3); |
| } |
| |
| byte code4[] = {kExprLocalGet, 0, 0, 0}; // [expr] [opcode] [opcode] |
| for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) { |
| code4[2] = kInt32BinopOpcodes[i]; |
| code4[3] = kInt32BinopOpcodes[i]; |
| ExpectFailure(sigs.i_i(), code4); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BinopsAcrossBlock1) { |
| ExpectFailure(sigs.i_i(), {WASM_ZERO, kExprBlock, kI32Code, WASM_ZERO, |
| kExprI32Add, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BinopsAcrossBlock2) { |
| ExpectFailure(sigs.i_i(), {WASM_ZERO, WASM_ZERO, kExprBlock, kI32Code, |
| kExprI32Add, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BinopsAcrossBlock3) { |
| ExpectFailure(sigs.i_i(), {WASM_ZERO, WASM_ZERO, kExprIf, kI32Code, |
| kExprI32Add, kExprElse, kExprI32Add, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Nop) { |
| ExpectValidates(sigs.v_v(), {kExprNop}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SetLocal0_void) { |
| ExpectFailure(sigs.i_i(), {WASM_SET_LOCAL(0, WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SetLocal0_param) { |
| ExpectFailure(sigs.i_i(), kCodeSetLocal0); |
| ExpectFailure(sigs.f_ff(), kCodeSetLocal0); |
| ExpectFailure(sigs.d_dd(), kCodeSetLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, TeeLocal0_param) { |
| ExpectValidates(sigs.i_i(), kCodeTeeLocal0); |
| ExpectFailure(sigs.f_ff(), kCodeTeeLocal0); |
| ExpectFailure(sigs.d_dd(), kCodeTeeLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SetLocal0_local) { |
| ExpectFailure(sigs.i_v(), kCodeSetLocal0); |
| ExpectFailure(sigs.v_v(), kCodeSetLocal0); |
| AddLocals(kWasmI32, 1); |
| ExpectFailure(sigs.i_v(), kCodeSetLocal0); |
| ExpectValidates(sigs.v_v(), kCodeSetLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, TeeLocal0_local) { |
| ExpectFailure(sigs.i_v(), kCodeTeeLocal0); |
| AddLocals(kWasmI32, 1); |
| ExpectValidates(sigs.i_v(), kCodeTeeLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, TeeLocalN_local) { |
| for (byte i = 1; i < 8; i++) { |
| AddLocals(kWasmI32, 1); |
| for (byte j = 0; j < i; j++) { |
| ExpectFailure(sigs.v_v(), {WASM_TEE_LOCAL(j, WASM_I32V_1(i))}); |
| ExpectValidates(sigs.i_i(), {WASM_TEE_LOCAL(j, WASM_I32V_1(i))}); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BlockN) { |
| constexpr size_t kMaxSize = 200; |
| byte buffer[kMaxSize + 3]; |
| |
| for (size_t i = 0; i <= kMaxSize; i++) { |
| memset(buffer, kExprNop, sizeof(buffer)); |
| buffer[0] = kExprBlock; |
| buffer[1] = kVoidCode; |
| buffer[i + 2] = kExprEnd; |
| ExpectValidates(sigs.v_i(), VectorOf(buffer, i + 3), kAppendEnd); |
| } |
| } |
| |
| #define WASM_EMPTY_BLOCK kExprBlock, kVoidCode, kExprEnd |
| |
| TEST_F(FunctionBodyDecoderTest, Block0) { |
| ExpectValidates(sigs.v_v(), {WASM_EMPTY_BLOCK}); |
| ExpectFailure(sigs.i_i(), {WASM_EMPTY_BLOCK}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block0_fallthru1) { |
| ExpectValidates(sigs.v_v(), {WASM_BLOCK(WASM_EMPTY_BLOCK)}); |
| ExpectFailure(sigs.i_i(), {WASM_BLOCK(WASM_EMPTY_BLOCK)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block0Block0) { |
| ExpectValidates(sigs.v_v(), {WASM_EMPTY_BLOCK, WASM_EMPTY_BLOCK}); |
| ExpectFailure(sigs.i_i(), {WASM_EMPTY_BLOCK, WASM_EMPTY_BLOCK}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block0_end) { |
| ExpectFailure(sigs.v_v(), {WASM_EMPTY_BLOCK, kExprEnd}); |
| } |
| |
| #undef WASM_EMPTY_BLOCK |
| |
| TEST_F(FunctionBodyDecoderTest, Block1) { |
| byte code[] = {WASM_BLOCK_I(WASM_GET_LOCAL(0))}; |
| ExpectValidates(sigs.i_i(), code); |
| ExpectFailure(sigs.v_i(), code); |
| ExpectFailure(sigs.d_dd(), code); |
| ExpectFailure(sigs.i_f(), code); |
| ExpectFailure(sigs.i_d(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block1_i) { |
| byte code[] = {WASM_BLOCK_I(WASM_ZERO)}; |
| ExpectValidates(sigs.i_i(), code); |
| ExpectFailure(sigs.f_ff(), code); |
| ExpectFailure(sigs.d_dd(), code); |
| ExpectFailure(sigs.l_ll(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block1_f) { |
| byte code[] = {WASM_BLOCK_F(WASM_F32(0))}; |
| ExpectFailure(sigs.i_i(), code); |
| ExpectValidates(sigs.f_ff(), code); |
| ExpectFailure(sigs.d_dd(), code); |
| ExpectFailure(sigs.l_ll(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block1_continue) { |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_BR(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block1_br) { |
| ExpectValidates(sigs.v_v(), {B1(WASM_BR(0))}); |
| ExpectValidates(sigs.v_v(), {B1(WASM_BR(1))}); |
| ExpectFailure(sigs.v_v(), {B1(WASM_BR(2))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block2_br) { |
| ExpectValidates(sigs.v_v(), {B2(WASM_NOP, WASM_BR(0))}); |
| ExpectValidates(sigs.v_v(), {B2(WASM_BR(0), WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {B2(WASM_BR(0), WASM_BR(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block2) { |
| ExpectFailure(sigs.i_i(), {WASM_BLOCK(WASM_NOP, WASM_NOP)}); |
| ExpectFailure(sigs.i_i(), {WASM_BLOCK_I(WASM_NOP, WASM_NOP)}); |
| ExpectValidates(sigs.i_i(), {WASM_BLOCK_I(WASM_NOP, WASM_ZERO)}); |
| ExpectValidates(sigs.i_i(), {WASM_BLOCK_I(WASM_ZERO, WASM_NOP)}); |
| ExpectFailure(sigs.i_i(), {WASM_BLOCK_I(WASM_ZERO, WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block2b) { |
| byte code[] = {WASM_BLOCK_I(WASM_SET_LOCAL(0, WASM_ZERO), WASM_ZERO)}; |
| ExpectValidates(sigs.i_i(), code); |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.f_ff(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block2_fallthru) { |
| ExpectValidates(sigs.i_i(), {B2(WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_SET_LOCAL(0, WASM_ZERO)), |
| WASM_I32V_1(23)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block3) { |
| ExpectValidates(sigs.i_i(), {WASM_BLOCK_I(WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_I32V_1(11))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block5) { |
| ExpectFailure(sigs.v_i(), {WASM_BLOCK(WASM_ZERO)}); |
| |
| ExpectFailure(sigs.v_i(), {WASM_BLOCK(WASM_ZERO, WASM_ZERO)}); |
| |
| ExpectFailure(sigs.v_i(), {WASM_BLOCK(WASM_ZERO, WASM_ZERO, WASM_ZERO)}); |
| |
| ExpectFailure(sigs.v_i(), |
| {WASM_BLOCK(WASM_ZERO, WASM_ZERO, WASM_ZERO, WASM_ZERO)}); |
| |
| ExpectFailure(sigs.v_i(), {WASM_BLOCK(WASM_ZERO, WASM_ZERO, WASM_ZERO, |
| WASM_ZERO, WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BlockType) { |
| ExpectValidates(sigs.i_i(), {WASM_BLOCK_I(WASM_GET_LOCAL(0))}); |
| ExpectValidates(sigs.l_l(), {WASM_BLOCK_L(WASM_GET_LOCAL(0))}); |
| ExpectValidates(sigs.f_f(), {WASM_BLOCK_F(WASM_GET_LOCAL(0))}); |
| ExpectValidates(sigs.d_d(), {WASM_BLOCK_D(WASM_GET_LOCAL(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BlockType_fail) { |
| ExpectFailure(sigs.i_i(), {WASM_BLOCK_L(WASM_I64V_1(0))}); |
| ExpectFailure(sigs.i_i(), {WASM_BLOCK_F(WASM_F32(0.0))}); |
| ExpectFailure(sigs.i_i(), {WASM_BLOCK_D(WASM_F64(1.1))}); |
| |
| ExpectFailure(sigs.l_l(), {WASM_BLOCK_I(WASM_ZERO)}); |
| ExpectFailure(sigs.l_l(), {WASM_BLOCK_F(WASM_F32(0.0))}); |
| ExpectFailure(sigs.l_l(), {WASM_BLOCK_D(WASM_F64(1.1))}); |
| |
| ExpectFailure(sigs.f_ff(), {WASM_BLOCK_I(WASM_ZERO)}); |
| ExpectFailure(sigs.f_ff(), {WASM_BLOCK_L(WASM_I64V_1(0))}); |
| ExpectFailure(sigs.f_ff(), {WASM_BLOCK_D(WASM_F64(1.1))}); |
| |
| ExpectFailure(sigs.d_dd(), {WASM_BLOCK_I(WASM_ZERO)}); |
| ExpectFailure(sigs.d_dd(), {WASM_BLOCK_L(WASM_I64V_1(0))}); |
| ExpectFailure(sigs.d_dd(), {WASM_BLOCK_F(WASM_F32(0.0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BlockF32) { |
| static const byte code[] = {WASM_BLOCK_F(kExprF32Const, 0, 0, 0, 0)}; |
| ExpectValidates(sigs.f_ff(), code); |
| ExpectFailure(sigs.i_i(), code); |
| ExpectFailure(sigs.d_dd(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BlockN_off_end) { |
| byte code[] = {WASM_BLOCK(kExprNop, kExprNop, kExprNop, kExprNop)}; |
| ExpectValidates(sigs.v_v(), code); |
| for (size_t i = 1; i < arraysize(code); i++) { |
| ExpectFailure(sigs.v_v(), VectorOf(code, i), kAppendEnd); |
| ExpectFailure(sigs.v_v(), VectorOf(code, i), kOmitEnd); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block2_continue) { |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_NOP, WASM_BR(0))}); |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_NOP, WASM_BR(1))}); |
| ExpectFailure(sigs.v_v(), {WASM_LOOP(WASM_NOP, WASM_BR(2))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block3_continue) { |
| ExpectValidates(sigs.v_v(), {B1(WASM_LOOP(WASM_NOP, WASM_BR(0)))}); |
| ExpectValidates(sigs.v_v(), {B1(WASM_LOOP(WASM_NOP, WASM_BR(1)))}); |
| ExpectValidates(sigs.v_v(), {B1(WASM_LOOP(WASM_NOP, WASM_BR(2)))}); |
| ExpectFailure(sigs.v_v(), {B1(WASM_LOOP(WASM_NOP, WASM_BR(3)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, NestedBlock_return) { |
| ExpectValidates(sigs.i_i(), {B1(B1(WASM_RETURN1(WASM_ZERO))), WASM_ZERO}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BlockBrBinop) { |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_AND(WASM_BLOCK_I(WASM_BRV(0, WASM_I32V_1(1))), |
| WASM_I32V_1(2))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, VoidBlockTypeVariants) { |
| // Valid kVoidCode encoded in 2 bytes. |
| ExpectValidates(sigs.v_v(), {kExprBlock, kVoidCode | 0x80, 0x7F, kExprEnd}); |
| // Invalid code, whose last 7 bits coincide with kVoidCode. |
| ExpectFailure(sigs.v_v(), {kExprBlock, kVoidCode | 0x80, 0x45, kExprEnd}, |
| kAppendEnd, "Invalid block type"); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_empty1) { |
| ExpectValidates(sigs.v_v(), {WASM_ZERO, WASM_IF_OP, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_empty2) { |
| ExpectValidates(sigs.v_v(), {WASM_ZERO, WASM_IF_OP, kExprElse, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_empty3) { |
| ExpectValidates(sigs.v_v(), |
| {WASM_ZERO, WASM_IF_OP, WASM_NOP, kExprElse, kExprEnd}); |
| ExpectFailure(sigs.v_v(), |
| {WASM_ZERO, WASM_IF_OP, WASM_ZERO, kExprElse, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_empty4) { |
| ExpectValidates(sigs.v_v(), |
| {WASM_ZERO, WASM_IF_OP, kExprElse, WASM_NOP, kExprEnd}); |
| ExpectFailure(sigs.v_v(), |
| {WASM_ZERO, WASM_IF_OP, kExprElse, WASM_ZERO, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_empty_stack) { |
| byte code[] = {kExprIf}; |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_incomplete1) { |
| byte code[] = {kExprI32Const, 0, kExprIf}; |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_incomplete2) { |
| byte code[] = {kExprI32Const, 0, kExprIf, kExprNop}; |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_else_else) { |
| byte code[] = {kExprI32Const, 0, WASM_IF_OP, kExprElse, kExprElse, kExprEnd}; |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfEmpty) { |
| ExpectValidates(sigs.v_i(), {kExprLocalGet, 0, WASM_IF_OP, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfSet) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO))}); |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfElseEmpty) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_GET_LOCAL(0), WASM_IF_OP, kExprElse, kExprEnd}); |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfElseUnreachable1) { |
| ExpectValidates( |
| sigs.i_i(), |
| {WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_UNREACHABLE, WASM_GET_LOCAL(0))}); |
| ExpectValidates( |
| sigs.i_i(), |
| {WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_UNREACHABLE)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfElseUnreachable2) { |
| static const byte code[] = { |
| WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_UNREACHABLE, WASM_GET_LOCAL(0))}; |
| |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| ValueType types[] = {kWasmI32, kValueTypes[i]}; |
| FunctionSig sig(1, 1, types); |
| |
| Validate(kValueTypes[i] == kWasmI32, &sig, code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, OneArmedIfWithArity) { |
| static const byte code[] = {WASM_ZERO, kExprIf, kI32Code, WASM_ONE, kExprEnd}; |
| ExpectFailure(sigs.i_v(), code, kAppendEnd, |
| "start-arity and end-arity of one-armed if must match"); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfBreak) { |
| ExpectValidates(sigs.v_i(), {WASM_IF(WASM_GET_LOCAL(0), WASM_BR(0))}); |
| ExpectValidates(sigs.v_i(), {WASM_IF(WASM_GET_LOCAL(0), WASM_BR(1))}); |
| ExpectFailure(sigs.v_i(), {WASM_IF(WASM_GET_LOCAL(0), WASM_BR(2))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfElseBreak) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_BR(0))}); |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_BR(1))}); |
| ExpectFailure(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_BR(2))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Block_else) { |
| byte code[] = {kExprI32Const, 0, kExprBlock, kExprElse, kExprEnd}; |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfNop) { |
| ExpectValidates(sigs.v_i(), {WASM_IF(WASM_GET_LOCAL(0), WASM_NOP)}); |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_end) { |
| ExpectValidates(sigs.v_i(), {kExprLocalGet, 0, WASM_IF_OP, kExprEnd}); |
| ExpectFailure(sigs.v_i(), {kExprLocalGet, 0, WASM_IF_OP, kExprEnd, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_falloff1) { |
| ExpectFailure(sigs.v_i(), {kExprLocalGet, 0, kExprIf}); |
| ExpectFailure(sigs.v_i(), {kExprLocalGet, 0, WASM_IF_OP}); |
| ExpectFailure(sigs.v_i(), |
| {kExprLocalGet, 0, WASM_IF_OP, kExprNop, kExprElse}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfElseNop) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfBlock1) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), |
| B1(WASM_SET_LOCAL(0, WASM_ZERO)), WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfBlock1b) { |
| ExpectValidates(sigs.v_i(), {WASM_IF(WASM_GET_LOCAL(0), |
| B1(WASM_SET_LOCAL(0, WASM_ZERO)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfBlock2a) { |
| ExpectValidates(sigs.v_i(), {WASM_IF(WASM_GET_LOCAL(0), |
| B2(WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_SET_LOCAL(0, WASM_ZERO)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfBlock2b) { |
| ExpectValidates(sigs.v_i(), {WASM_IF_ELSE(WASM_GET_LOCAL(0), |
| B2(WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_SET_LOCAL(0, WASM_ZERO)), |
| WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IfElseSet) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_SET_LOCAL(0, WASM_I32V_1(1)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop0) { |
| ExpectValidates(sigs.v_v(), {WASM_LOOP_OP, kExprEnd}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop1) { |
| static const byte code[] = {WASM_LOOP(WASM_SET_LOCAL(0, WASM_ZERO))}; |
| ExpectValidates(sigs.v_i(), code); |
| ExpectFailure(sigs.v_v(), code); |
| ExpectFailure(sigs.f_ff(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop2) { |
| ExpectValidates(sigs.v_i(), {WASM_LOOP(WASM_SET_LOCAL(0, WASM_ZERO), |
| WASM_SET_LOCAL(0, WASM_ZERO))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop1_continue) { |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_BR(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop1_break) { |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_BR(1))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop2_continue) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_LOOP(WASM_SET_LOCAL(0, WASM_ZERO), WASM_BR(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop2_break) { |
| ExpectValidates(sigs.v_i(), |
| {WASM_LOOP(WASM_SET_LOCAL(0, WASM_ZERO), WASM_BR(1))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, InfiniteLoop1) { |
| ExpectValidates(sigs.i_i(), {WASM_LOOP(WASM_BR(0)), WASM_ZERO}); |
| ExpectValidates(sigs.i_i(), {WASM_LOOP(WASM_BR(0)), WASM_ZERO}); |
| ExpectValidates(sigs.i_i(), {WASM_LOOP_I(WASM_BRV(1, WASM_ZERO))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, InfiniteLoop2) { |
| ExpectFailure(sigs.i_i(), {WASM_LOOP(WASM_BR(0), WASM_ZERO), WASM_ZERO}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Loop2_unreachable) { |
| ExpectValidates(sigs.i_i(), {WASM_LOOP_I(WASM_BR(0), WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, LoopType) { |
| ExpectValidates(sigs.i_i(), {WASM_LOOP_I(WASM_GET_LOCAL(0))}); |
| ExpectValidates(sigs.l_l(), {WASM_LOOP_L(WASM_GET_LOCAL(0))}); |
| ExpectValidates(sigs.f_f(), {WASM_LOOP_F(WASM_GET_LOCAL(0))}); |
| ExpectValidates(sigs.d_d(), {WASM_LOOP_D(WASM_GET_LOCAL(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, LoopType_void) { |
| ExpectFailure(sigs.v_v(), {WASM_LOOP_I(WASM_ZERO)}); |
| ExpectFailure(sigs.v_v(), {WASM_LOOP_L(WASM_I64V_1(0))}); |
| ExpectFailure(sigs.v_v(), {WASM_LOOP_F(WASM_F32(0.0))}); |
| ExpectFailure(sigs.v_v(), {WASM_LOOP_D(WASM_F64(1.1))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, LoopType_fail) { |
| ExpectFailure(sigs.i_i(), {WASM_LOOP_L(WASM_I64V_1(0))}); |
| ExpectFailure(sigs.i_i(), {WASM_LOOP_F(WASM_F32(0.0))}); |
| ExpectFailure(sigs.i_i(), {WASM_LOOP_D(WASM_F64(1.1))}); |
| |
| ExpectFailure(sigs.l_l(), {WASM_LOOP_I(WASM_ZERO)}); |
| ExpectFailure(sigs.l_l(), {WASM_LOOP_F(WASM_F32(0.0))}); |
| ExpectFailure(sigs.l_l(), {WASM_LOOP_D(WASM_F64(1.1))}); |
| |
| ExpectFailure(sigs.f_ff(), {WASM_LOOP_I(WASM_ZERO)}); |
| ExpectFailure(sigs.f_ff(), {WASM_LOOP_L(WASM_I64V_1(0))}); |
| ExpectFailure(sigs.f_ff(), {WASM_LOOP_D(WASM_F64(1.1))}); |
| |
| ExpectFailure(sigs.d_dd(), {WASM_LOOP_I(WASM_ZERO)}); |
| ExpectFailure(sigs.d_dd(), {WASM_LOOP_L(WASM_I64V_1(0))}); |
| ExpectFailure(sigs.d_dd(), {WASM_LOOP_F(WASM_F32(0.0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, ReturnVoid1) { |
| static const byte code[] = {kExprNop}; |
| ExpectValidates(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| ExpectFailure(sigs.i_f(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, ReturnVoid2) { |
| static const byte code[] = {WASM_BLOCK(WASM_BR(0))}; |
| ExpectValidates(sigs.v_v(), code); |
| ExpectFailure(sigs.i_i(), code); |
| ExpectFailure(sigs.i_f(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, ReturnVoid3) { |
| ExpectFailure(sigs.v_v(), {kExprI32Const, 0}); |
| ExpectFailure(sigs.v_v(), {kExprI64Const, 0}); |
| ExpectFailure(sigs.v_v(), {kExprF32Const, 0, 0, 0, 0}); |
| ExpectFailure(sigs.v_v(), {kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0}); |
| ExpectFailure(sigs.v_v(), {kExprRefNull}); |
| ExpectFailure(sigs.v_v(), {kExprRefFunc, 0}); |
| |
| ExpectFailure(sigs.v_i(), {kExprLocalGet, 0}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Unreachable1) { |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE}); |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, WASM_UNREACHABLE}); |
| ExpectValidates(sigs.i_i(), {WASM_UNREACHABLE, WASM_ZERO}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Unreachable2) { |
| ExpectFailure(sigs.v_v(), {B2(WASM_UNREACHABLE, WASM_ZERO)}); |
| ExpectFailure(sigs.v_v(), {B2(WASM_BR(0), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, UnreachableLoop1) { |
| ExpectFailure(sigs.v_v(), {WASM_LOOP(WASM_UNREACHABLE, WASM_ZERO)}); |
| ExpectFailure(sigs.v_v(), {WASM_LOOP(WASM_BR(0), WASM_ZERO)}); |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_UNREACHABLE, WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_BR(0), WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Unreachable_binop1) { |
| ExpectValidates(sigs.i_i(), {WASM_I32_AND(WASM_ZERO, WASM_UNREACHABLE)}); |
| ExpectValidates(sigs.i_i(), {WASM_I32_AND(WASM_UNREACHABLE, WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Unreachable_binop2) { |
| ExpectValidates(sigs.i_i(), {WASM_I32_AND(WASM_F32(0.0), WASM_UNREACHABLE)}); |
| ExpectFailure(sigs.i_i(), {WASM_I32_AND(WASM_UNREACHABLE, WASM_F32(0.0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Unreachable_select1) { |
| ExpectValidates(sigs.i_i(), |
| {WASM_SELECT(WASM_UNREACHABLE, WASM_ZERO, WASM_ZERO)}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_SELECT(WASM_ZERO, WASM_UNREACHABLE, WASM_ZERO)}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_SELECT(WASM_ZERO, WASM_ZERO, WASM_UNREACHABLE)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Unreachable_select2) { |
| ExpectValidates(sigs.i_i(), |
| {WASM_SELECT(WASM_F32(0.0), WASM_UNREACHABLE, WASM_ZERO)}); |
| ExpectFailure(sigs.i_i(), |
| {WASM_SELECT(WASM_UNREACHABLE, WASM_F32(0.0), WASM_ZERO)}); |
| ExpectFailure(sigs.i_i(), |
| {WASM_SELECT(WASM_UNREACHABLE, WASM_ZERO, WASM_F32(0.0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, UnreachableRefTypes) { |
| WASM_FEATURE_SCOPE(reftypes); |
| WASM_FEATURE_SCOPE(typed_funcref); |
| WASM_FEATURE_SCOPE(gc); |
| WASM_FEATURE_SCOPE(return_call); |
| |
| byte function_index = builder.AddFunction(sigs.i_ii()); |
| byte struct_index = builder.AddStruct({F(kWasmI32, true), F(kWasmI64, true)}); |
| byte array_index = builder.AddArray(kWasmI32, true); |
| |
| ValueType struct_type = ValueType::Ref(struct_index, kNonNullable); |
| FunctionSig sig_v_s(0, 1, &struct_type); |
| byte struct_consumer = builder.AddFunction(&sig_v_s); |
| |
| ExpectValidates(sigs.v_v(), {WASM_BLOCK(WASM_UNREACHABLE, kExprBrOnNull, 0)}); |
| ExpectValidates(sigs.i_v(), {WASM_UNREACHABLE, kExprRefIsNull}); |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, kExprRefAsNonNull, kExprDrop}); |
| |
| ExpectValidates(sigs.i_v(), {WASM_UNREACHABLE, kExprCallRef, WASM_I32V(1)}); |
| ExpectValidates(sigs.i_v(), {WASM_UNREACHABLE, WASM_REF_FUNC(function_index), |
| kExprCallRef}); |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, kExprReturnCallRef}); |
| |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_GC_OP(kExprStructNewWithRtt), |
| struct_index, kExprCallFunction, struct_consumer}); |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, WASM_RTT_CANON(struct_index), |
| WASM_GC_OP(kExprStructNewWithRtt), struct_index, |
| kExprCallFunction, struct_consumer}); |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, WASM_I64V(42), |
| WASM_RTT_CANON(struct_index), |
| WASM_GC_OP(kExprStructNewWithRtt), struct_index, |
| kExprCallFunction, struct_consumer}); |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_GC_OP(kExprStructNewDefault), |
| struct_index, kExprDrop}); |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, WASM_RTT_CANON(struct_index), |
| WASM_GC_OP(kExprStructNewDefault), struct_index, |
| kExprCallFunction, struct_consumer}); |
| |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_GC_OP(kExprArrayNewWithRtt), |
| array_index, kExprDrop}); |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_RTT_CANON(array_index), |
| WASM_GC_OP(kExprArrayNewWithRtt), array_index, kExprDrop}); |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_I32V(42), WASM_RTT_CANON(array_index), |
| WASM_GC_OP(kExprArrayNewWithRtt), array_index, kExprDrop}); |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_GC_OP(kExprArrayNewDefault), |
| array_index, kExprDrop}); |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_RTT_CANON(array_index), |
| WASM_GC_OP(kExprArrayNewDefault), array_index, kExprDrop}); |
| |
| ExpectValidates(sigs.i_v(), {WASM_UNREACHABLE, WASM_GC_OP(kExprRefTest), |
| struct_index, struct_index}); |
| ExpectValidates(sigs.i_v(), |
| {WASM_UNREACHABLE, WASM_RTT_CANON(struct_index), |
| WASM_GC_OP(kExprRefTest), struct_index, struct_index}); |
| |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, WASM_GC_OP(kExprRefCast), |
| struct_index, struct_index, kExprDrop}); |
| ExpectValidates(sigs.v_v(), {WASM_UNREACHABLE, WASM_RTT_CANON(struct_index), |
| WASM_GC_OP(kExprRefCast), struct_index, |
| struct_index, kExprDrop}); |
| |
| ExpectValidates(sigs.v_v(), |
| {WASM_UNREACHABLE, WASM_GC_OP(kExprRttSub), array_index, |
| WASM_GC_OP(kExprRttSub), array_index, kExprDrop}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If1) { |
| ExpectValidates(sigs.i_i(), {WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_I32V_1(9), |
| WASM_I32V_1(8))}); |
| ExpectValidates(sigs.i_i(), {WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_I32V_1(9), |
| WASM_GET_LOCAL(0))}); |
| ExpectValidates( |
| sigs.i_i(), |
| {WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_I32V_1(8))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_off_end) { |
| static const byte kCode[] = { |
| WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_GET_LOCAL(0))}; |
| for (size_t len = 3; len < arraysize(kCode); len++) { |
| ExpectFailure(sigs.i_i(), VectorOf(kCode, len), kAppendEnd); |
| ExpectFailure(sigs.i_i(), VectorOf(kCode, len), kOmitEnd); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_type1) { |
| // float|double ? 1 : 2 |
| static const byte kCode[] = { |
| WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_I32V_1(0), WASM_I32V_1(2))}; |
| ExpectValidates(sigs.i_i(), kCode); |
| ExpectFailure(sigs.i_f(), kCode); |
| ExpectFailure(sigs.i_d(), kCode); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_type2) { |
| // 1 ? float|double : 2 |
| static const byte kCode[] = { |
| WASM_IF_ELSE_I(WASM_I32V_1(1), WASM_GET_LOCAL(0), WASM_I32V_1(1))}; |
| ExpectValidates(sigs.i_i(), kCode); |
| ExpectFailure(sigs.i_f(), kCode); |
| ExpectFailure(sigs.i_d(), kCode); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_type3) { |
| // stmt ? 0 : 1 |
| static const byte kCode[] = { |
| WASM_IF_ELSE_I(WASM_NOP, WASM_I32V_1(0), WASM_I32V_1(1))}; |
| ExpectFailure(sigs.i_i(), kCode); |
| ExpectFailure(sigs.i_f(), kCode); |
| ExpectFailure(sigs.i_d(), kCode); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_type4) { |
| // 0 ? stmt : 1 |
| static const byte kCode[] = { |
| WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_NOP, WASM_I32V_1(1))}; |
| ExpectFailure(sigs.i_i(), kCode); |
| ExpectFailure(sigs.i_f(), kCode); |
| ExpectFailure(sigs.i_d(), kCode); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, If_type5) { |
| // 0 ? 1 : stmt |
| static const byte kCode[] = { |
| WASM_IF_ELSE_I(WASM_ZERO, WASM_I32V_1(1), WASM_NOP)}; |
| ExpectFailure(sigs.i_i(), kCode); |
| ExpectFailure(sigs.i_f(), kCode); |
| ExpectFailure(sigs.i_d(), kCode); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int64Local_param) { |
| ExpectValidates(sigs.l_l(), kCodeGetLocal0); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int64Locals) { |
| for (byte i = 1; i < 8; i++) { |
| AddLocals(kWasmI64, 1); |
| for (byte j = 0; j < i; j++) { |
| ExpectValidates(sigs.l_v(), {WASM_GET_LOCAL(j)}); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Binops) { |
| TestBinop(kExprI32Add, sigs.i_ii()); |
| TestBinop(kExprI32Sub, sigs.i_ii()); |
| TestBinop(kExprI32Mul, sigs.i_ii()); |
| TestBinop(kExprI32DivS, sigs.i_ii()); |
| TestBinop(kExprI32DivU, sigs.i_ii()); |
| TestBinop(kExprI32RemS, sigs.i_ii()); |
| TestBinop(kExprI32RemU, sigs.i_ii()); |
| TestBinop(kExprI32And, sigs.i_ii()); |
| TestBinop(kExprI32Ior, sigs.i_ii()); |
| TestBinop(kExprI32Xor, sigs.i_ii()); |
| TestBinop(kExprI32Shl, sigs.i_ii()); |
| TestBinop(kExprI32ShrU, sigs.i_ii()); |
| TestBinop(kExprI32ShrS, sigs.i_ii()); |
| TestBinop(kExprI32Eq, sigs.i_ii()); |
| TestBinop(kExprI32LtS, sigs.i_ii()); |
| TestBinop(kExprI32LeS, sigs.i_ii()); |
| TestBinop(kExprI32LtU, sigs.i_ii()); |
| TestBinop(kExprI32LeU, sigs.i_ii()); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, DoubleBinops) { |
| TestBinop(kExprF64Add, sigs.d_dd()); |
| TestBinop(kExprF64Sub, sigs.d_dd()); |
| TestBinop(kExprF64Mul, sigs.d_dd()); |
| TestBinop(kExprF64Div, sigs.d_dd()); |
| |
| TestBinop(kExprF64Eq, sigs.i_dd()); |
| TestBinop(kExprF64Lt, sigs.i_dd()); |
| TestBinop(kExprF64Le, sigs.i_dd()); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, FloatBinops) { |
| TestBinop(kExprF32Add, sigs.f_ff()); |
| TestBinop(kExprF32Sub, sigs.f_ff()); |
| TestBinop(kExprF32Mul, sigs.f_ff()); |
| TestBinop(kExprF32Div, sigs.f_ff()); |
| |
| TestBinop(kExprF32Eq, sigs.i_ff()); |
| TestBinop(kExprF32Lt, sigs.i_ff()); |
| TestBinop(kExprF32Le, sigs.i_ff()); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, TypeConversions) { |
| TestUnop(kExprI32SConvertF32, kWasmI32, kWasmF32); |
| TestUnop(kExprI32SConvertF64, kWasmI32, kWasmF64); |
| TestUnop(kExprI32UConvertF32, kWasmI32, kWasmF32); |
| TestUnop(kExprI32UConvertF64, kWasmI32, kWasmF64); |
| TestUnop(kExprF64SConvertI32, kWasmF64, kWasmI32); |
| TestUnop(kExprF64UConvertI32, kWasmF64, kWasmI32); |
| TestUnop(kExprF64ConvertF32, kWasmF64, kWasmF32); |
| TestUnop(kExprF32SConvertI32, kWasmF32, kWasmI32); |
| TestUnop(kExprF32UConvertI32, kWasmF32, kWasmI32); |
| TestUnop(kExprF32ConvertF64, kWasmF32, kWasmF64); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MacrosStmt) { |
| builder.InitializeMemory(); |
| ExpectValidates(sigs.v_i(), {WASM_SET_LOCAL(0, WASM_I32V_3(87348))}); |
| ExpectValidates( |
| sigs.v_i(), |
| {WASM_STORE_MEM(MachineType::Int32(), WASM_I32V_1(24), WASM_I32V_1(40))}); |
| ExpectValidates(sigs.v_i(), {WASM_IF(WASM_GET_LOCAL(0), WASM_NOP)}); |
| ExpectValidates(sigs.v_i(), |
| {WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {WASM_NOP}); |
| ExpectValidates(sigs.v_v(), {B1(WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_BR(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MacrosContinue) { |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_CONTINUE(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MacrosVariadic) { |
| ExpectValidates(sigs.v_v(), {B2(WASM_NOP, WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {B3(WASM_NOP, WASM_NOP, WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_NOP, WASM_NOP)}); |
| ExpectValidates(sigs.v_v(), {WASM_LOOP(WASM_NOP, WASM_NOP, WASM_NOP)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MacrosNestedBlocks) { |
| ExpectValidates(sigs.v_v(), {B2(WASM_NOP, B2(WASM_NOP, WASM_NOP))}); |
| ExpectValidates(sigs.v_v(), {B3(WASM_NOP, // -- |
| B2(WASM_NOP, WASM_NOP), // -- |
| B2(WASM_NOP, WASM_NOP))}); // -- |
| ExpectValidates(sigs.v_v(), {B1(B1(B2(WASM_NOP, WASM_NOP)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MultipleReturn) { |
| static ValueType kIntTypes5[] = {kWasmI32, kWasmI32, kWasmI32, kWasmI32, |
| kWasmI32}; |
| FunctionSig sig_ii_v(2, 0, kIntTypes5); |
| ExpectValidates(&sig_ii_v, {WASM_RETURNN(2, WASM_ZERO, WASM_ONE)}); |
| ExpectFailure(&sig_ii_v, {WASM_RETURNN(1, WASM_ZERO)}); |
| |
| FunctionSig sig_iii_v(3, 0, kIntTypes5); |
| ExpectValidates(&sig_iii_v, |
| {WASM_RETURNN(3, WASM_ZERO, WASM_ONE, WASM_I32V_1(44))}); |
| ExpectFailure(&sig_iii_v, {WASM_RETURNN(2, WASM_ZERO, WASM_ONE)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MultipleReturn_fallthru) { |
| static ValueType kIntTypes5[] = {kWasmI32, kWasmI32, kWasmI32, kWasmI32, |
| kWasmI32}; |
| FunctionSig sig_ii_v(2, 0, kIntTypes5); |
| |
| ExpectValidates(&sig_ii_v, {WASM_ZERO, WASM_ONE}); |
| ExpectFailure(&sig_ii_v, {WASM_ZERO}); |
| |
| FunctionSig sig_iii_v(3, 0, kIntTypes5); |
| ExpectValidates(&sig_iii_v, {WASM_ZERO, WASM_ONE, WASM_I32V_1(44)}); |
| ExpectFailure(&sig_iii_v, {WASM_ZERO, WASM_ONE}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MacrosInt32) { |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_I32V_1(12))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V_1(13))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_I32V_1(14))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I32V_1(15))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I32V_1(16))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_I32V_1(17))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_I32V_1(18))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_AND(WASM_GET_LOCAL(0), WASM_I32V_1(19))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_IOR(WASM_GET_LOCAL(0), WASM_I32V_1(20))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_XOR(WASM_GET_LOCAL(0), WASM_I32V_1(21))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_SHL(WASM_GET_LOCAL(0), WASM_I32V_1(22))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_SHR(WASM_GET_LOCAL(0), WASM_I32V_1(23))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_SAR(WASM_GET_LOCAL(0), WASM_I32V_1(24))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_ROR(WASM_GET_LOCAL(0), WASM_I32V_1(24))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_ROL(WASM_GET_LOCAL(0), WASM_I32V_1(24))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(25))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_NE(WASM_GET_LOCAL(0), WASM_I32V_1(25))}); |
| |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_LTS(WASM_GET_LOCAL(0), WASM_I32V_1(26))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_LES(WASM_GET_LOCAL(0), WASM_I32V_1(27))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_LTU(WASM_GET_LOCAL(0), WASM_I32V_1(28))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_LEU(WASM_GET_LOCAL(0), WASM_I32V_1(29))}); |
| |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_GTS(WASM_GET_LOCAL(0), WASM_I32V_1(26))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_GES(WASM_GET_LOCAL(0), WASM_I32V_1(27))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_GTU(WASM_GET_LOCAL(0), WASM_I32V_1(28))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_I32_GEU(WASM_GET_LOCAL(0), WASM_I32V_1(29))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MacrosInt64) { |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_I64V_1(12))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_I64V_1(13))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_MUL(WASM_GET_LOCAL(0), WASM_I64V_1(14))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64V_1(15))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64V_1(16))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_I64V_1(17))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_I64V_1(18))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_AND(WASM_GET_LOCAL(0), WASM_I64V_1(19))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_I64V_1(20))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_I64V_1(21))}); |
| |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(22))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(23))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(24))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_I64V_1(24))}); |
| ExpectValidates(sigs.l_ll(), |
| {WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_I64V_1(24))}); |
| |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_I64V_1(26))}); |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_LES(WASM_GET_LOCAL(0), WASM_I64V_1(27))}); |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_I64V_1(28))}); |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_I64V_1(29))}); |
| |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_I64V_1(26))}); |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_GES(WASM_GET_LOCAL(0), WASM_I64V_1(27))}); |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_I64V_1(28))}); |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_I64V_1(29))}); |
| |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_I64V_1(25))}); |
| ExpectValidates(sigs.i_ll(), |
| {WASM_I64_NE(WASM_GET_LOCAL(0), WASM_I64V_1(25))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AllSimpleExpressions) { |
| WASM_FEATURE_SCOPE(reftypes); |
| // Test all simple expressions which are described by a signature. |
| #define DECODE_TEST(name, opcode, sig) \ |
| { \ |
| const FunctionSig* sig = WasmOpcodes::Signature(kExpr##name); \ |
| if (sig->parameter_count() == 1) { \ |
| TestUnop(kExpr##name, sig); \ |
| } else { \ |
| TestBinop(kExpr##name, sig); \ |
| } \ |
| } |
| |
| FOREACH_SIMPLE_OPCODE(DECODE_TEST); |
| |
| #undef DECODE_TEST |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MemorySize) { |
| builder.InitializeMemory(); |
| byte code[] = {kExprMemorySize, 0}; |
| ExpectValidates(sigs.i_i(), code); |
| ExpectFailure(sigs.f_ff(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, LoadMemOffset) { |
| builder.InitializeMemory(); |
| for (int offset = 0; offset < 128; offset += 7) { |
| byte code[] = {kExprI32Const, 0, kExprI32LoadMem, ZERO_ALIGNMENT, |
| static_cast<byte>(offset)}; |
| ExpectValidates(sigs.i_i(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, LoadMemAlignment) { |
| builder.InitializeMemory(); |
| struct { |
| WasmOpcode instruction; |
| uint32_t maximum_aligment; |
| } values[] = { |
| {kExprI32LoadMem8U, 0}, // -- |
| {kExprI32LoadMem8S, 0}, // -- |
| {kExprI32LoadMem16U, 1}, // -- |
| {kExprI32LoadMem16S, 1}, // -- |
| {kExprI64LoadMem8U, 0}, // -- |
| {kExprI64LoadMem8S, 0}, // -- |
| {kExprI64LoadMem16U, 1}, // -- |
| {kExprI64LoadMem16S, 1}, // -- |
| {kExprI64LoadMem32U, 2}, // -- |
| {kExprI64LoadMem32S, 2}, // -- |
| {kExprI32LoadMem, 2}, // -- |
| {kExprI64LoadMem, 3}, // -- |
| {kExprF32LoadMem, 2}, // -- |
| {kExprF64LoadMem, 3}, // -- |
| }; |
| |
| for (size_t i = 0; i < arraysize(values); i++) { |
| for (byte alignment = 0; alignment <= 4; alignment++) { |
| byte code[] = {WASM_ZERO, static_cast<byte>(values[i].instruction), |
| alignment, ZERO_OFFSET, WASM_DROP}; |
| Validate(alignment <= values[i].maximum_aligment, sigs.v_i(), code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, StoreMemOffset) { |
| builder.InitializeMemory(); |
| for (byte offset = 0; offset < 128; offset += 7) { |
| byte code[] = {WASM_STORE_MEM_OFFSET(MachineType::Int32(), offset, |
| WASM_ZERO, WASM_ZERO)}; |
| ExpectValidates(sigs.v_i(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, StoreMemOffset_void) { |
| builder.InitializeMemory(); |
| ExpectFailure(sigs.i_i(), {WASM_STORE_MEM_OFFSET(MachineType::Int32(), 0, |
| WASM_ZERO, WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, LoadMemOffset_varint) { |
| builder.InitializeMemory(); |
| ExpectValidates(sigs.i_i(), |
| {WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT, U32V_1(0x45)}); |
| ExpectValidates(sigs.i_i(), {WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT, |
| U32V_2(0x3999)}); |
| ExpectValidates(sigs.i_i(), {WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT, |
| U32V_3(0x344445)}); |
| ExpectValidates(sigs.i_i(), {WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT, |
| U32V_4(0x36666667)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, StoreMemOffset_varint) { |
| builder.InitializeMemory(); |
| ExpectValidates(sigs.v_i(), {WASM_ZERO, WASM_ZERO, kExprI32StoreMem, |
| ZERO_ALIGNMENT, U32V_1(0x33)}); |
| ExpectValidates(sigs.v_i(), {WASM_ZERO, WASM_ZERO, kExprI32StoreMem, |
| ZERO_ALIGNMENT, U32V_2(0x1111)}); |
| ExpectValidates(sigs.v_i(), {WASM_ZERO, WASM_ZERO, kExprI32StoreMem, |
| ZERO_ALIGNMENT, U32V_3(0x222222)}); |
| ExpectValidates(sigs.v_i(), {WASM_ZERO, WASM_ZERO, kExprI32StoreMem, |
| ZERO_ALIGNMENT, U32V_4(0x44444444)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AllLoadMemCombinations) { |
| builder.InitializeMemory(); |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| ValueType local_type = kValueTypes[i]; |
| for (size_t j = 0; j < arraysize(machineTypes); j++) { |
| MachineType mem_type = machineTypes[j]; |
| byte code[] = {WASM_LOAD_MEM(mem_type, WASM_ZERO)}; |
| FunctionSig sig(1, 0, &local_type); |
| Validate(local_type == ValueType::For(mem_type), &sig, code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AllStoreMemCombinations) { |
| builder.InitializeMemory(); |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| ValueType local_type = kValueTypes[i]; |
| for (size_t j = 0; j < arraysize(machineTypes); j++) { |
| MachineType mem_type = machineTypes[j]; |
| byte code[] = {WASM_STORE_MEM(mem_type, WASM_ZERO, WASM_GET_LOCAL(0))}; |
| FunctionSig sig(0, 1, &local_type); |
| Validate(local_type == ValueType::For(mem_type), &sig, code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SimpleCalls) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddFunction(sigs.i_v()); |
| builder.AddFunction(sigs.i_i()); |
| builder.AddFunction(sigs.i_ii()); |
| |
| ExpectValidates(sig, {WASM_CALL_FUNCTION0(0)}); |
| ExpectValidates(sig, {WASM_CALL_FUNCTION(1, WASM_I32V_1(27))}); |
| ExpectValidates(sig, |
| {WASM_CALL_FUNCTION(2, WASM_I32V_1(37), WASM_I32V_2(77))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, CallsWithTooFewArguments) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddFunction(sigs.i_i()); |
| builder.AddFunction(sigs.i_ii()); |
| builder.AddFunction(sigs.f_ff()); |
| |
| ExpectFailure(sig, {WASM_CALL_FUNCTION0(0)}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(1, WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(2, WASM_GET_LOCAL(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, CallsWithMismatchedSigs2) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddFunction(sigs.i_i()); |
| |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(0, WASM_I64V_1(17))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(0, WASM_F32(17.1))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(0, WASM_F64(17.1))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, CallsWithMismatchedSigs3) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddFunction(sigs.i_f()); |
| |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(0, WASM_I32V_1(17))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(0, WASM_I64V_1(27))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(0, WASM_F64(37.2))}); |
| |
| builder.AddFunction(sigs.i_d()); |
| |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(1, WASM_I32V_1(16))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(1, WASM_I64V_1(16))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(1, WASM_F32(17.6))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SimpleReturnCalls) { |
| WASM_FEATURE_SCOPE(return_call); |
| |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddFunction(sigs.i_v()); |
| builder.AddFunction(sigs.i_i()); |
| builder.AddFunction(sigs.i_ii()); |
| |
| ExpectValidates(sig, {WASM_RETURN_CALL_FUNCTION0(0)}); |
| ExpectValidates(sig, {WASM_RETURN_CALL_FUNCTION(1, WASM_I32V_1(27))}); |
| ExpectValidates( |
| sig, {WASM_RETURN_CALL_FUNCTION(2, WASM_I32V_1(37), WASM_I32V_2(77))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, ReturnCallsWithTooFewArguments) { |
| WASM_FEATURE_SCOPE(return_call); |
| |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddFunction(sigs.i_i()); |
| builder.AddFunction(sigs.i_ii()); |
| builder.AddFunction(sigs.f_ff()); |
| |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION0(0)}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(1, WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(2, WASM_GET_LOCAL(0))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, ReturnCallsWithMismatchedSigs) { |
| WASM_FEATURE_SCOPE(return_call); |
| |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddFunction(sigs.i_f()); |
| builder.AddFunction(sigs.f_f()); |
| |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(0, WASM_I32V_1(17))}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(0, WASM_I64V_1(27))}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(0, WASM_F64(37.2))}); |
| |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(1, WASM_F64(37.2))}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(1, WASM_F32(37.2))}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_FUNCTION(1, WASM_I32V_1(17))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SimpleIndirectReturnCalls) { |
| WASM_FEATURE_SCOPE(return_call); |
| |
| const FunctionSig* sig = sigs.i_i(); |
| builder.AddTable(kWasmFuncRef, 20, true, 30); |
| |
| byte sig0 = builder.AddSignature(sigs.i_v()); |
| byte sig1 = builder.AddSignature(sigs.i_i()); |
| byte sig2 = builder.AddSignature(sigs.i_ii()); |
| |
| ExpectValidates(sig, {WASM_RETURN_CALL_INDIRECT(sig0, WASM_ZERO)}); |
| ExpectValidates( |
| sig, {WASM_RETURN_CALL_INDIRECT(sig1, WASM_I32V_1(22), WASM_ZERO)}); |
| ExpectValidates(sig, {WASM_RETURN_CALL_INDIRECT(sig2, WASM_I32V_1(32), |
| WASM_I32V_2(72), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IndirectReturnCallsOutOfBounds) { |
| WASM_FEATURE_SCOPE(return_call); |
| |
| const FunctionSig* sig = sigs.i_i(); |
| builder.AddTable(kWasmFuncRef, 20, false, 20); |
| |
| ExpectFailure(sig, {WASM_RETURN_CALL_INDIRECT(0, WASM_ZERO)}); |
| builder.AddSignature(sigs.i_v()); |
| ExpectValidates(sig, {WASM_RETURN_CALL_INDIRECT(0, WASM_ZERO)}); |
| |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(1, WASM_I32V_1(22), WASM_ZERO)}); |
| builder.AddSignature(sigs.i_i()); |
| ExpectValidates(sig, |
| {WASM_RETURN_CALL_INDIRECT(1, WASM_I32V_1(27), WASM_ZERO)}); |
| |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(2, WASM_I32V_1(27), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IndirectReturnCallsWithMismatchedSigs3) { |
| WASM_FEATURE_SCOPE(return_call); |
| |
| const FunctionSig* sig = sigs.i_i(); |
| builder.InitializeTable(wasm::kWasmStmt); |
| |
| byte sig0 = builder.AddSignature(sigs.i_f()); |
| |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(sig0, WASM_I32V_1(17), WASM_ZERO)}); |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(sig0, WASM_I64V_1(27), WASM_ZERO)}); |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(sig0, WASM_F64(37.2), WASM_ZERO)}); |
| |
| ExpectFailure(sig, {WASM_RETURN_CALL_INDIRECT(sig0, WASM_I32V_1(17))}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_INDIRECT(sig0, WASM_I64V_1(27))}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_INDIRECT(sig0, WASM_F64(37.2))}); |
| |
| byte sig1 = builder.AddFunction(sigs.i_d()); |
| |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(sig1, WASM_I32V_1(16), WASM_ZERO)}); |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(sig1, WASM_I64V_1(16), WASM_ZERO)}); |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(sig1, WASM_F32(17.6), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IndirectReturnCallsWithoutTableCrash) { |
| WASM_FEATURE_SCOPE(return_call); |
| |
| const FunctionSig* sig = sigs.i_i(); |
| |
| byte sig0 = builder.AddSignature(sigs.i_v()); |
| byte sig1 = builder.AddSignature(sigs.i_i()); |
| byte sig2 = builder.AddSignature(sigs.i_ii()); |
| |
| ExpectFailure(sig, {WASM_RETURN_CALL_INDIRECT(sig0, WASM_ZERO)}); |
| ExpectFailure(sig, |
| {WASM_RETURN_CALL_INDIRECT(sig1, WASM_I32V_1(22), WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_RETURN_CALL_INDIRECT(sig2, WASM_I32V_1(32), |
| WASM_I32V_2(72), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IncompleteIndirectReturnCall) { |
| const FunctionSig* sig = sigs.i_i(); |
| builder.InitializeTable(wasm::kWasmStmt); |
| |
| static byte code[] = {kExprReturnCallIndirect}; |
| ExpectFailure(sig, ArrayVector(code), kOmitEnd); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MultiReturn) { |
| WASM_FEATURE_SCOPE(mv); |
| ValueType storage[] = {kWasmI32, kWasmI32}; |
| FunctionSig sig_ii_v(2, 0, storage); |
| FunctionSig sig_v_ii(0, 2, storage); |
| |
| builder.AddFunction(&sig_v_ii); |
| builder.AddFunction(&sig_ii_v); |
| |
| ExpectValidates(&sig_ii_v, {WASM_CALL_FUNCTION0(1)}); |
| ExpectValidates(sigs.v_v(), {WASM_CALL_FUNCTION0(1), WASM_DROP, WASM_DROP}); |
| ExpectValidates(sigs.v_v(), {WASM_CALL_FUNCTION0(1), kExprCallFunction, 0}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MultiReturnType) { |
| WASM_FEATURE_SCOPE(mv); |
| for (size_t a = 0; a < arraysize(kValueTypes); a++) { |
| for (size_t b = 0; b < arraysize(kValueTypes); b++) { |
| for (size_t c = 0; c < arraysize(kValueTypes); c++) { |
| for (size_t d = 0; d < arraysize(kValueTypes); d++) { |
| ValueType storage_ab[] = {kValueTypes[a], kValueTypes[b]}; |
| FunctionSig sig_ab_v(2, 0, storage_ab); |
| ValueType storage_cd[] = {kValueTypes[c], kValueTypes[d]}; |
| FunctionSig sig_cd_v(2, 0, storage_cd); |
| |
| TestModuleBuilder builder; |
| module = builder.module(); |
| builder.AddFunction(&sig_cd_v); |
| |
| ExpectValidates(&sig_cd_v, {WASM_CALL_FUNCTION0(0)}); |
| |
| if (IsSubtypeOf(kValueTypes[c], kValueTypes[a], module) && |
| IsSubtypeOf(kValueTypes[d], kValueTypes[b], module)) { |
| ExpectValidates(&sig_ab_v, {WASM_CALL_FUNCTION0(0)}); |
| } else { |
| ExpectFailure(&sig_ab_v, {WASM_CALL_FUNCTION0(0)}); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SimpleIndirectCalls) { |
| const FunctionSig* sig = sigs.i_i(); |
| builder.AddTable(kWasmFuncRef, 20, false, 20); |
| |
| byte sig0 = builder.AddSignature(sigs.i_v()); |
| byte sig1 = builder.AddSignature(sigs.i_i()); |
| byte sig2 = builder.AddSignature(sigs.i_ii()); |
| |
| ExpectValidates(sig, {WASM_CALL_INDIRECT(sig0, WASM_ZERO)}); |
| ExpectValidates(sig, {WASM_CALL_INDIRECT(sig1, WASM_I32V_1(22), WASM_ZERO)}); |
| ExpectValidates(sig, {WASM_CALL_INDIRECT(sig2, WASM_I32V_1(32), |
| WASM_I32V_2(72), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IndirectCallsOutOfBounds) { |
| const FunctionSig* sig = sigs.i_i(); |
| builder.AddTable(kWasmFuncRef, 20, false, 20); |
| |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(0, WASM_ZERO)}); |
| builder.AddSignature(sigs.i_v()); |
| ExpectValidates(sig, {WASM_CALL_INDIRECT(0, WASM_ZERO)}); |
| |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(1, WASM_I32V_1(22), WASM_ZERO)}); |
| builder.AddSignature(sigs.i_i()); |
| ExpectValidates(sig, {WASM_CALL_INDIRECT(1, WASM_I32V_1(27), WASM_ZERO)}); |
| |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(2, WASM_I32V_1(27), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IndirectCallsWithMismatchedSigs1) { |
| const FunctionSig* sig = sigs.i_i(); |
| builder.InitializeTable(wasm::kWasmStmt); |
| |
| byte sig0 = builder.AddSignature(sigs.i_f()); |
| |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig0, WASM_I32V_1(17), WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig0, WASM_I64V_1(27), WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig0, WASM_F64(37.2), WASM_ZERO)}); |
| |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig0, WASM_I32V_1(17))}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig0, WASM_I64V_1(27))}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig0, WASM_F64(37.2))}); |
| |
| byte sig1 = builder.AddFunction(sigs.i_d()); |
| |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig1, WASM_I32V_1(16), WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig1, WASM_I64V_1(16), WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig1, WASM_F32(17.6), WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IndirectCallsWithMismatchedSigs2) { |
| WASM_FEATURE_SCOPE(reftypes); |
| WASM_FEATURE_SCOPE(typed_funcref); |
| byte table_type_index = builder.AddSignature(sigs.i_i()); |
| byte table_index = |
| builder.InitializeTable(ValueType::Ref(table_type_index, kNullable)); |
| |
| ExpectValidates(sigs.i_v(), |
| {WASM_CALL_INDIRECT_TABLE(table_index, table_type_index, |
| WASM_I32V_1(42), WASM_ZERO)}); |
| |
| byte wrong_type_index = builder.AddSignature(sigs.i_ii()); |
| ExpectFailure(sigs.i_v(), |
| {WASM_CALL_INDIRECT_TABLE(table_index, wrong_type_index, |
| WASM_I32V_1(42), WASM_ZERO)}, |
| kAppendEnd, |
| "call_indirect: Immediate signature #1 is not a subtype of " |
| "immediate table #0"); |
| |
| byte non_function_table_index = builder.InitializeTable(kWasmExternRef); |
| ExpectFailure( |
| sigs.i_v(), |
| {WASM_CALL_INDIRECT_TABLE(non_function_table_index, table_type_index, |
| WASM_I32V_1(42), WASM_ZERO)}, |
| kAppendEnd, |
| "call_indirect: immediate table #1 is not of a function type"); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IndirectCallsWithoutTableCrash) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| byte sig0 = builder.AddSignature(sigs.i_v()); |
| byte sig1 = builder.AddSignature(sigs.i_i()); |
| byte sig2 = builder.AddSignature(sigs.i_ii()); |
| |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig0, WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig1, WASM_I32V_1(22), WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_CALL_INDIRECT(sig2, WASM_I32V_1(32), WASM_I32V_2(72), |
| WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IncompleteIndirectCall) { |
| const FunctionSig* sig = sigs.i_i(); |
| builder.InitializeTable(wasm::kWasmStmt); |
| |
| static byte code[] = {kExprCallIndirect}; |
| ExpectFailure(sig, ArrayVector(code), kOmitEnd); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IncompleteStore) { |
| const FunctionSig* sig = sigs.i_i(); |
| builder.InitializeMemory(); |
| builder.InitializeTable(wasm::kWasmStmt); |
| |
| static byte code[] = {kExprI32StoreMem}; |
| ExpectFailure(sig, ArrayVector(code), kOmitEnd); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, IncompleteI8x16Shuffle) { |
| WASM_FEATURE_SCOPE(simd); |
| const FunctionSig* sig = sigs.i_i(); |
| builder.InitializeMemory(); |
| builder.InitializeTable(wasm::kWasmStmt); |
| |
| static byte code[] = {kSimdPrefix, |
| static_cast<byte>(kExprI8x16Shuffle & 0xff)}; |
| ExpectFailure(sig, ArrayVector(code), kOmitEnd); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, SimpleImportCalls) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| byte f0 = builder.AddImport(sigs.i_v()); |
| byte f1 = builder.AddImport(sigs.i_i()); |
| byte f2 = builder.AddImport(sigs.i_ii()); |
| |
| ExpectValidates(sig, {WASM_CALL_FUNCTION0(f0)}); |
| ExpectValidates(sig, {WASM_CALL_FUNCTION(f1, WASM_I32V_1(22))}); |
| ExpectValidates(sig, |
| {WASM_CALL_FUNCTION(f2, WASM_I32V_1(32), WASM_I32V_2(72))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, ImportCallsWithMismatchedSigs3) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| byte f0 = builder.AddImport(sigs.i_f()); |
| |
| ExpectFailure(sig, {WASM_CALL_FUNCTION0(f0)}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(f0, WASM_I32V_1(17))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(f0, WASM_I64V_1(27))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(f0, WASM_F64(37.2))}); |
| |
| byte f1 = builder.AddImport(sigs.i_d()); |
| |
| ExpectFailure(sig, {WASM_CALL_FUNCTION0(f1)}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(f1, WASM_I32V_1(16))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(f1, WASM_I64V_1(16))}); |
| ExpectFailure(sig, {WASM_CALL_FUNCTION(f1, WASM_F32(17.6))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Globals) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddGlobal(kWasmI32); |
| |
| ExpectValidates(sig, {WASM_GET_GLOBAL(0)}); |
| ExpectFailure(sig, {WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0))}); |
| ExpectValidates(sig, {WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0)), WASM_ZERO}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, ImmutableGlobal) { |
| const FunctionSig* sig = sigs.v_v(); |
| |
| uint32_t g0 = builder.AddGlobal(kWasmI32, true); |
| uint32_t g1 = builder.AddGlobal(kWasmI32, false); |
| |
| ExpectValidates(sig, {WASM_SET_GLOBAL(g0, WASM_ZERO)}); |
| ExpectFailure(sig, {WASM_SET_GLOBAL(g1, WASM_ZERO)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int32Globals_fail) { |
| const FunctionSig* sig = sigs.i_i(); |
| |
| builder.AddGlobal(kWasmI64); |
| builder.AddGlobal(kWasmI64); |
| builder.AddGlobal(kWasmF32); |
| builder.AddGlobal(kWasmF64); |
| |
| ExpectFailure(sig, {WASM_GET_GLOBAL(0)}); |
| ExpectFailure(sig, {WASM_GET_GLOBAL(1)}); |
| ExpectFailure(sig, {WASM_GET_GLOBAL(2)}); |
| ExpectFailure(sig, {WASM_GET_GLOBAL(3)}); |
| |
| ExpectFailure(sig, {WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0)), WASM_ZERO}); |
| ExpectFailure(sig, {WASM_SET_GLOBAL(1, WASM_GET_LOCAL(0)), WASM_ZERO}); |
| ExpectFailure(sig, {WASM_SET_GLOBAL(2, WASM_GET_LOCAL(0)), WASM_ZERO}); |
| ExpectFailure(sig, {WASM_SET_GLOBAL(3, WASM_GET_LOCAL(0)), WASM_ZERO}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Int64Globals) { |
| const FunctionSig* sig = sigs.l_l(); |
| |
| builder.AddGlobal(kWasmI64); |
| builder.AddGlobal(kWasmI64); |
| |
| ExpectValidates(sig, {WASM_GET_GLOBAL(0)}); |
| ExpectValidates(sig, {WASM_GET_GLOBAL(1)}); |
| |
| ExpectValidates(sig, |
| {WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0)), WASM_GET_LOCAL(0)}); |
| ExpectValidates(sig, |
| {WASM_SET_GLOBAL(1, WASM_GET_LOCAL(0)), WASM_GET_LOCAL(0)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Float32Globals) { |
| const FunctionSig* sig = sigs.f_ff(); |
| |
| builder.AddGlobal(kWasmF32); |
| |
| ExpectValidates(sig, {WASM_GET_GLOBAL(0)}); |
| ExpectValidates(sig, |
| {WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0)), WASM_GET_LOCAL(0)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Float64Globals) { |
| const FunctionSig* sig = sigs.d_dd(); |
| |
| builder.AddGlobal(kWasmF64); |
| |
| ExpectValidates(sig, {WASM_GET_GLOBAL(0)}); |
| ExpectValidates(sig, |
| {WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0)), WASM_GET_LOCAL(0)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AllGetGlobalCombinations) { |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| ValueType local_type = kValueTypes[i]; |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| ValueType global_type = kValueTypes[j]; |
| FunctionSig sig(1, 0, &local_type); |
| TestModuleBuilder builder; |
| module = builder.module(); |
| builder.AddGlobal(global_type); |
| Validate(IsSubtypeOf(global_type, local_type, module), &sig, |
| {WASM_GET_GLOBAL(0)}); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AllSetGlobalCombinations) { |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| ValueType local_type = kValueTypes[i]; |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| ValueType global_type = kValueTypes[j]; |
| FunctionSig sig(0, 1, &local_type); |
| TestModuleBuilder builder; |
| module = builder.module(); |
| builder.AddGlobal(global_type); |
| Validate(IsSubtypeOf(local_type, global_type, module), &sig, |
| {WASM_SET_GLOBAL(0, WASM_GET_LOCAL(0))}); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, TableSet) { |
| WASM_FEATURE_SCOPE(reftypes); |
| WASM_FEATURE_SCOPE(typed_funcref); |
| |
| byte tab_type = builder.AddSignature(sigs.i_i()); |
| byte tab_ref1 = builder.AddTable(kWasmExternRef, 10, true, 20); |
| byte tab_func1 = builder.AddTable(kWasmFuncRef, 20, true, 30); |
| byte tab_func2 = builder.AddTable(kWasmFuncRef, 10, false, 20); |
| byte tab_ref2 = builder.AddTable(kWasmExternRef, 10, false, 20); |
| byte tab_typed_func = |
| builder.AddTable(ValueType::Ref(tab_type, kNullable), 10, false, 20); |
| |
| ValueType sig_types[]{kWasmExternRef, kWasmFuncRef, kWasmI32, |
| ValueType::Ref(tab_type, kNonNullable)}; |
| FunctionSig sig(0, 4, sig_types); |
| byte local_ref = 0; |
| byte local_func = 1; |
| byte local_int = 2; |
| byte local_typed_func = 3; |
| |
| ExpectValidates(&sig, {WASM_TABLE_SET(tab_ref1, WASM_I32V(6), |
| WASM_GET_LOCAL(local_ref))}); |
| ExpectValidates(&sig, {WASM_TABLE_SET(tab_func1, WASM_I32V(5), |
| WASM_GET_LOCAL(local_func))}); |
| ExpectValidates(&sig, {WASM_TABLE_SET(tab_func2, WASM_I32V(7), |
| WASM_GET_LOCAL(local_func))}); |
| ExpectValidates(&sig, {WASM_TABLE_SET(tab_ref2, WASM_I32V(8), |
| WASM_GET_LOCAL(local_ref))}); |
| ExpectValidates(&sig, {WASM_TABLE_SET(tab_typed_func, WASM_I32V(8), |
| WASM_GET_LOCAL(local_typed_func))}); |
| ExpectValidates(&sig, {WASM_TABLE_SET(tab_func1, WASM_I32V(8), |
| WASM_GET_LOCAL(local_typed_func))}); |
| |
| // Only values of the correct type can be set to a table. |
| ExpectFailure(&sig, {WASM_TABLE_SET(tab_ref1, WASM_I32V(4), |
| WASM_GET_LOCAL(local_func))}); |
| ExpectFailure(&sig, {WASM_TABLE_SET(tab_func1, WASM_I32V(9), |
| WASM_GET_LOCAL(local_ref))}); |
| ExpectFailure(&sig, {WASM_TABLE_SET(tab_func2, WASM_I32V(3), |
| WASM_GET_LOCAL(local_ref))}); |
| ExpectFailure(&sig, {WASM_TABLE_SET(tab_ref2, WASM_I32V(2), |
| WASM_GET_LOCAL(local_func))}); |
| ExpectFailure(&sig, {WASM_TABLE_SET(tab_ref1, WASM_I32V(9), |
| WASM_GET_LOCAL(local_int))}); |
| ExpectFailure(&sig, {WASM_TABLE_SET(tab_func1, WASM_I32V(3), |
| WASM_GET_LOCAL(local_int))}); |
| ExpectFailure(&sig, {WASM_TABLE_SET(tab_typed_func, WASM_I32V(3), |
| WASM_GET_LOCAL(local_func))}); |
| |
| // Out-of-bounds table index should fail. |
| byte oob_tab = 37; |
| ExpectFailure( |
| &sig, {WASM_TABLE_SET(oob_tab, WASM_I32V(9), WASM_GET_LOCAL(local_ref))}); |
| ExpectFailure(&sig, {WASM_TABLE_SET(oob_tab, WASM_I32V(3), |
| WASM_GET_LOCAL(local_func))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, TableGet) { |
| WASM_FEATURE_SCOPE(reftypes); |
| WASM_FEATURE_SCOPE(typed_funcref); |
| |
| byte tab_type = builder.AddSignature(sigs.i_i()); |
| byte tab_ref1 = builder.AddTable(kWasmExternRef, 10, true, 20); |
| byte tab_func1 = builder.AddTable(kWasmFuncRef, 20, true, 30); |
| byte tab_func2 = builder.AddTable(kWasmFuncRef, 10, false, 20); |
| byte tab_ref2 = builder.AddTable(kWasmExternRef, 10, false, 20); |
| byte tab_typed_func = |
| builder.AddTable(ValueType::Ref(tab_type, kNullable), 10, false, 20); |
| |
| ValueType sig_types[]{kWasmExternRef, kWasmFuncRef, kWasmI32, |
| ValueType::Ref(tab_type, kNullable)}; |
| FunctionSig sig(0, 4, sig_types); |
| byte local_ref = 0; |
| byte local_func = 1; |
| byte local_int = 2; |
| byte local_typed_func = 3; |
| |
| ExpectValidates( |
| &sig, |
| {WASM_SET_LOCAL(local_ref, WASM_TABLE_GET(tab_ref1, WASM_I32V(6)))}); |
| ExpectValidates( |
| &sig, |
| {WASM_SET_LOCAL(local_ref, WASM_TABLE_GET(tab_ref2, WASM_I32V(8)))}); |
| ExpectValidates( |
| &sig, |
| {WASM_SET_LOCAL(local_func, WASM_TABLE_GET(tab_func1, WASM_I32V(5)))}); |
| ExpectValidates( |
| &sig, |
| {WASM_SET_LOCAL(local_func, WASM_TABLE_GET(tab_func2, WASM_I32V(7)))}); |
| ExpectValidates( |
| &sig, {WASM_SET_LOCAL(local_ref, WASM_SEQ(WASM_I32V(6), kExprTableGet, |
| U32V_2(tab_ref1)))}); |
| ExpectValidates( |
| &sig, {WASM_SET_LOCAL(local_func, |
| WASM_TABLE_GET(tab_typed_func, WASM_I32V(7)))}); |
| ExpectValidates( |
| &sig, {WASM_SET_LOCAL(local_typed_func, |
| WASM_TABLE_GET(tab_typed_func, WASM_I32V(7)))}); |
| |
| // We cannot store references as any other type. |
| ExpectFailure(&sig, {WASM_SET_LOCAL(local_func, |
| WASM_TABLE_GET(tab_ref1, WASM_I32V(4)))}); |
| ExpectFailure(&sig, {WASM_SET_LOCAL( |
| local_ref, WASM_TABLE_GET(tab_func1, WASM_I32V(9)))}); |
| ExpectFailure(&sig, {WASM_SET_LOCAL( |
| local_ref, WASM_TABLE_GET(tab_func2, WASM_I32V(3)))}); |
| ExpectFailure(&sig, {WASM_SET_LOCAL(local_func, |
| WASM_TABLE_GET(tab_ref2, WASM_I32V(2)))}); |
| |
| ExpectFailure(&sig, {WASM_SET_LOCAL(local_int, |
| WASM_TABLE_GET(tab_ref1, WASM_I32V(9)))}); |
| ExpectFailure(&sig, {WASM_SET_LOCAL( |
| local_int, WASM_TABLE_GET(tab_func1, WASM_I32V(3)))}); |
| ExpectFailure(&sig, |
| {WASM_SET_LOCAL(local_typed_func, |
| WASM_TABLE_GET(tab_func1, WASM_I32V(3)))}); |
| |
| // Out-of-bounds table index should fail. |
| byte oob_tab = 37; |
| ExpectFailure( |
| &sig, {WASM_SET_LOCAL(local_ref, WASM_TABLE_GET(oob_tab, WASM_I32V(9)))}); |
| ExpectFailure(&sig, {WASM_SET_LOCAL(local_func, |
| WASM_TABLE_GET(oob_tab, WASM_I32V(3)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, MultiTableCallIndirect) { |
| WASM_FEATURE_SCOPE(reftypes); |
| byte tab_ref = builder.AddTable(kWasmExternRef, 10, true, 20); |
| byte tab_func = builder.AddTable(kWasmFuncRef, 20, true, 30); |
| |
| ValueType sig_types[]{kWasmExternRef, kWasmFuncRef, kWasmI32}; |
| FunctionSig sig(0, 3, sig_types); |
| byte sig_index = builder.AddSignature(sigs.i_v()); |
| |
| // We can store funcref values as externref, but not the other way around. |
| ExpectValidates(sigs.i_v(), |
| {kExprI32Const, 0, kExprCallIndirect, sig_index, tab_func}); |
| |
| ExpectFailure(sigs.i_v(), |
| {kExprI32Const, 0, kExprCallIndirect, sig_index, tab_ref}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, WasmMemoryGrow) { |
| builder.InitializeMemory(); |
| |
| byte code[] = {WASM_GET_LOCAL(0), kExprMemoryGrow, 0}; |
| ExpectValidates(sigs.i_i(), code); |
| ExpectFailure(sigs.i_d(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AsmJsMemoryGrow) { |
| module->origin = kAsmJsSloppyOrigin; |
| builder.InitializeMemory(); |
| |
| byte code[] = {WASM_GET_LOCAL(0), kExprMemoryGrow, 0}; |
| ExpectFailure(sigs.i_i(), code); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AsmJsBinOpsCheckOrigin) { |
| ValueType float32int32float32[] = {kWasmF32, kWasmI32, kWasmF32}; |
| FunctionSig sig_f_if(1, 2, float32int32float32); |
| ValueType float64int32float64[] = {kWasmF64, kWasmI32, kWasmF64}; |
| FunctionSig sig_d_id(1, 2, float64int32float64); |
| struct { |
| WasmOpcode op; |
| const FunctionSig* sig; |
| } AsmJsBinOps[] = { |
| {kExprF64Atan2, sigs.d_dd()}, |
| {kExprF64Pow, sigs.d_dd()}, |
| {kExprF64Mod, sigs.d_dd()}, |
| {kExprI32AsmjsDivS, sigs.i_ii()}, |
| {kExprI32AsmjsDivU, sigs.i_ii()}, |
| {kExprI32AsmjsRemS, sigs.i_ii()}, |
| {kExprI32AsmjsRemU, sigs.i_ii()}, |
| {kExprI32AsmjsStoreMem8, sigs.i_ii()}, |
| {kExprI32AsmjsStoreMem16, sigs.i_ii()}, |
| {kExprI32AsmjsStoreMem, sigs.i_ii()}, |
| {kExprF32AsmjsStoreMem, &sig_f_if}, |
| {kExprF64AsmjsStoreMem, &sig_d_id}, |
| }; |
| |
| { |
| TestModuleBuilder builder(kAsmJsSloppyOrigin); |
| module = builder.module(); |
| builder.InitializeMemory(); |
| for (size_t i = 0; i < arraysize(AsmJsBinOps); i++) { |
| TestBinop(AsmJsBinOps[i].op, AsmJsBinOps[i].sig); |
| } |
| } |
| |
| { |
| TestModuleBuilder builder; |
| module = builder.module(); |
| builder.InitializeMemory(); |
| for (size_t i = 0; i < arraysize(AsmJsBinOps); i++) { |
| ExpectFailure(AsmJsBinOps[i].sig, |
| {WASM_BINOP(AsmJsBinOps[i].op, WASM_GET_LOCAL(0), |
| WASM_GET_LOCAL(1))}); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, AsmJsUnOpsCheckOrigin) { |
| ValueType float32int32[] = {kWasmF32, kWasmI32}; |
| FunctionSig sig_f_i(1, 1, float32int32); |
| ValueType float64int32[] = {kWasmF64, kWasmI32}; |
| FunctionSig sig_d_i(1, 1, float64int32); |
| struct { |
| WasmOpcode op; |
| const FunctionSig* sig; |
| } AsmJsUnOps[] = {{kExprF64Acos, sigs.d_d()}, |
| {kExprF64Asin, sigs.d_d()}, |
| {kExprF64Atan, sigs.d_d()}, |
| {kExprF64Cos, sigs.d_d()}, |
| {kExprF64Sin, sigs.d_d()}, |
| {kExprF64Tan, sigs.d_d()}, |
| {kExprF64Exp, sigs.d_d()}, |
| {kExprF64Log, sigs.d_d()}, |
| {kExprI32AsmjsLoadMem8S, sigs.i_i()}, |
| {kExprI32AsmjsLoadMem8U, sigs.i_i()}, |
| {kExprI32AsmjsLoadMem16S, sigs.i_i()}, |
| {kExprI32AsmjsLoadMem16U, sigs.i_i()}, |
| {kExprI32AsmjsLoadMem, sigs.i_i()}, |
| {kExprF32AsmjsLoadMem, &sig_f_i}, |
| {kExprF64AsmjsLoadMem, &sig_d_i}, |
| {kExprI32AsmjsSConvertF32, sigs.i_f()}, |
| {kExprI32AsmjsUConvertF32, sigs.i_f()}, |
| {kExprI32AsmjsSConvertF64, sigs.i_d()}, |
| {kExprI32AsmjsUConvertF64, sigs.i_d()}}; |
| { |
| TestModuleBuilder builder(kAsmJsSloppyOrigin); |
| module = builder.module(); |
| builder.InitializeMemory(); |
| for (size_t i = 0; i < arraysize(AsmJsUnOps); i++) { |
| TestUnop(AsmJsUnOps[i].op, AsmJsUnOps[i].sig); |
| } |
| } |
| |
| { |
| TestModuleBuilder builder; |
| module = builder.module(); |
| builder.InitializeMemory(); |
| for (size_t i = 0; i < arraysize(AsmJsUnOps); i++) { |
| ExpectFailure(AsmJsUnOps[i].sig, |
| {WASM_UNOP(AsmJsUnOps[i].op, WASM_GET_LOCAL(0))}); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakEnd) { |
| ExpectValidates( |
| sigs.i_i(), |
| {WASM_BLOCK_I(WASM_I32_ADD(WASM_BRV(0, WASM_ZERO), WASM_ZERO))}); |
| ExpectValidates( |
| sigs.i_i(), |
| {WASM_BLOCK_I(WASM_I32_ADD(WASM_ZERO, WASM_BRV(0, WASM_ZERO)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakIfBinop) { |
| ExpectValidates(sigs.i_i(), |
| {WASM_BLOCK_I(WASM_I32_ADD( |
| WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO), WASM_ZERO))}); |
| ExpectValidates(sigs.i_i(), |
| {WASM_BLOCK_I(WASM_I32_ADD( |
| WASM_ZERO, WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO)))}); |
| ExpectValidates( |
| sigs.f_ff(), |
| {WASM_BLOCK_F(WASM_F32_ABS(WASM_BRV_IF(0, WASM_F32(0.0f), WASM_ZERO)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakIfBinop_fail) { |
| ExpectFailure( |
| sigs.f_ff(), |
| {WASM_BLOCK_F(WASM_F32_ABS(WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO)))}); |
| ExpectFailure( |
| sigs.i_i(), |
| {WASM_BLOCK_I(WASM_F32_ABS(WASM_BRV_IF(0, WASM_F32(0.0f), WASM_ZERO)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakIfUnrNarrow) { |
| ExpectFailure( |
| sigs.f_ff(), |
| {WASM_BLOCK_I(WASM_BRV_IF(0, WASM_UNREACHABLE, WASM_UNREACHABLE), |
| WASM_RETURN0), |
| WASM_F32(0.0)}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakNesting1) { |
| for (int i = 0; i < 5; i++) { |
| // (block[2] (loop[2] (if (get p) break[N]) (set p 1)) p) |
| byte code[] = {WASM_BLOCK_I( |
| WASM_LOOP(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(i + 1, WASM_ZERO)), |
| WASM_SET_LOCAL(0, WASM_I32V_1(1))), |
| WASM_ZERO)}; |
| Validate(i < 3, sigs.i_i(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakNesting2) { |
| for (int i = 0; i < 7; i++) { |
| byte code[] = {B1(WASM_LOOP(WASM_IF(WASM_ZERO, WASM_BR(i)), WASM_NOP))}; |
| Validate(i <= 3, sigs.v_v(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakNesting3) { |
| for (int i = 0; i < 7; i++) { |
| // (block[1] (loop[1] (block[1] (if 0 break[N]) |
| byte code[] = { |
| WASM_BLOCK(WASM_LOOP(B1(WASM_IF(WASM_ZERO, WASM_BR(i + 1)))))}; |
| Validate(i < 4, sigs.v_v(), code); |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreaksWithMultipleTypes) { |
| ExpectFailure(sigs.i_i(), |
| {B2(WASM_BRV_IF_ZERO(0, WASM_I32V_1(7)), WASM_F32(7.7))}); |
| |
| ExpectFailure(sigs.i_i(), {B2(WASM_BRV_IF_ZERO(0, WASM_I32V_1(7)), |
| WASM_BRV_IF_ZERO(0, WASM_F32(7.7)))}); |
| ExpectFailure(sigs.i_i(), {B3(WASM_BRV_IF_ZERO(0, WASM_I32V_1(8)), |
| WASM_BRV_IF_ZERO(0, WASM_I32V_1(0)), |
| WASM_BRV_IF_ZERO(0, WASM_F32(7.7)))}); |
| ExpectFailure(sigs.i_i(), {B3(WASM_BRV_IF_ZERO(0, WASM_I32V_1(9)), |
| WASM_BRV_IF_ZERO(0, WASM_F32(7.7)), |
| WASM_BRV_IF_ZERO(0, WASM_I32V_1(11)))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakNesting_6_levels) { |
| for (int mask = 0; mask < 64; mask++) { |
| for (int i = 0; i < 14; i++) { |
| byte code[] = {WASM_BLOCK(WASM_BLOCK( |
| WASM_BLOCK(WASM_BLOCK(WASM_BLOCK(WASM_BLOCK(WASM_BR(i)))))))}; |
| |
| int depth = 6; |
| int m = mask; |
| for (size_t pos = 0; pos < sizeof(code) - 1; pos++) { |
| if (code[pos] != kExprBlock) continue; |
| if (m & 1) { |
| code[pos] = kExprLoop; |
| code[pos + 1] = kVoidCode; |
| } |
| m >>= 1; |
| } |
| |
| Validate(i <= depth, sigs.v_v(), code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Break_TypeCheck) { |
| for (const FunctionSig* sig : |
| {sigs.i_i(), sigs.l_l(), sigs.f_ff(), sigs.d_dd()}) { |
| // unify X and X => OK |
| byte code[] = {WASM_BLOCK_T( |
| sig->GetReturn(), WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))), |
| WASM_GET_LOCAL(0))}; |
| ExpectValidates(sig, code); |
| } |
| |
| // unify i32 and f32 => fail |
| ExpectFailure(sigs.i_i(), |
| {WASM_BLOCK_I(WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_ZERO)), |
| WASM_F32(1.2))}); |
| |
| // unify f64 and f64 => OK |
| ExpectValidates( |
| sigs.d_dd(), |
| {WASM_BLOCK_D(WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))), |
| WASM_F64(1.2))}); |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Break_TypeCheckAll1) { |
| WASM_FEATURE_SCOPE(reftypes); |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| ValueType storage[] = {kValueTypes[i], kValueTypes[i], kValueTypes[j]}; |
| FunctionSig sig(1, 2, storage); |
| byte code[] = {WASM_BLOCK_T( |
| sig.GetReturn(), WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))), |
| WASM_GET_LOCAL(1))}; |
| |
| Validate(IsSubtypeOf(kValueTypes[j], kValueTypes[i], module), &sig, code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Break_TypeCheckAll2) { |
| WASM_FEATURE_SCOPE(reftypes); |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| ValueType storage[] = {kValueTypes[i], kValueTypes[i], kValueTypes[j]}; |
| FunctionSig sig(1, 2, storage); |
| byte code[] = {WASM_IF_ELSE_T(sig.GetReturn(0), WASM_ZERO, |
| WASM_BRV_IF_ZERO(0, WASM_GET_LOCAL(0)), |
| WASM_GET_LOCAL(1))}; |
| |
| Validate(IsSubtypeOf(kValueTypes[j], kValueTypes[i], module), &sig, code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Break_TypeCheckAll3) { |
| WASM_FEATURE_SCOPE(reftypes); |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| ValueType storage[] = {kValueTypes[i], kValueTypes[i], kValueTypes[j]}; |
| FunctionSig sig(1, 2, storage); |
| byte code[] = {WASM_IF_ELSE_T(sig.GetReturn(), WASM_ZERO, |
| WASM_GET_LOCAL(1), |
| WASM_BRV_IF_ZERO(0, WASM_GET_LOCAL(0)))}; |
| |
| Validate(IsSubtypeOf(kValueTypes[j], kValueTypes[i], module), &sig, code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, Break_Unify) { |
| for (int which = 0; which < 2; which++) { |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| ValueType type = kValueTypes[i]; |
| ValueType storage[] = {kWasmI32, kWasmI32, type}; |
| FunctionSig sig(1, 2, storage); |
| |
| byte code1[] = {WASM_BLOCK_T( |
| type, WASM_IF(WASM_ZERO, WASM_BRV(1, WASM_GET_LOCAL(which))), |
| WASM_GET_LOCAL(which ^ 1))}; |
| |
| Validate(type == kWasmI32, &sig, code1); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakIf_cond_type) { |
| WASM_FEATURE_SCOPE(reftypes); |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) { |
| for (size_t j = 0; j < arraysize(kValueTypes); j++) { |
| ValueType types[] = {kValueTypes[i], kValueTypes[i], kValueTypes[j]}; |
| FunctionSig sig(1, 2, types); |
| byte code[] = {WASM_BLOCK_T( |
| types[0], WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)))}; |
| |
| Validate(types[2] == kWasmI32, &sig, code); |
| } |
| } |
| } |
| |
| TEST_F(FunctionBodyDecoderTest, BreakIf_val_type) { |
| WASM_FEATURE_SCOPE(reftypes); |
| for (size_t i = 0; i < arraysize(kValueTypes); i++) |