v8/test/unittests/wasm/module-decoder-unittest.cc
Clemens Hammacher 45618a9ab5 [wasm] Make prototype flags experimental
Most prototype implementations are not fully supported in the
interpreter. This is the case at least for exception handling, simd, and
atomics. Any function can be redirected to the interpreter though,
either by passing --wasm-interpret-all, or by dynamically redirecting to
the interpreter for debugging.
Making the flags experimental keeps the fuzzer from playing around with
these flags.

Drive-by: Refactor tests which explicitly set the prototype flag to use
a new scope for that.

R=ahaas@chromium.org
BUG=chromium:727584

Change-Id: I67da79f579f1ac93c67189afef40c6524bdd4430
Reviewed-on: https://chromium-review.googlesource.com/519402
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45639}
2017-05-31 14:18:08 +00:00

1605 lines
51 KiB
C++

// 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 "test/unittests/test-utils.h"
#include "src/handles.h"
#include "src/objects-inl.h"
#include "src/wasm/module-decoder.h"
#include "src/wasm/wasm-limits.h"
#include "src/wasm/wasm-opcodes.h"
#include "test/common/wasm/flag-utils.h"
#include "test/common/wasm/wasm-macro-gen.h"
namespace v8 {
namespace internal {
namespace wasm {
#define WASM_INIT_EXPR_I32V_1(val) WASM_I32V_1(val), kExprEnd
#define WASM_INIT_EXPR_I32V_2(val) WASM_I32V_2(val), kExprEnd
#define WASM_INIT_EXPR_I32V_3(val) WASM_I32V_3(val), kExprEnd
#define WASM_INIT_EXPR_I32V_4(val) WASM_I32V_4(val), kExprEnd
#define WASM_INIT_EXPR_I32V_5(val) WASM_I32V_5(val), kExprEnd
#define WASM_INIT_EXPR_F32(val) WASM_F32(val), kExprEnd
#define WASM_INIT_EXPR_I64(val) WASM_I64(val), kExprEnd
#define WASM_INIT_EXPR_F64(val) WASM_F64(val), kExprEnd
#define WASM_INIT_EXPR_GLOBAL(index) WASM_GET_GLOBAL(index), kExprEnd
#define SIZEOF_EMPTY_FUNCTION ((size_t)5)
#define EMPTY_BODY 0
#define SIZEOF_EMPTY_BODY ((size_t)1)
#define NOP_BODY 2, 0, kExprNop
#define SIZEOF_NOP_BODY ((size_t)3)
#define SIG_ENTRY_i_i SIG_ENTRY_x_x(kLocalI32, kLocalI32)
#define UNKNOWN_SECTION(size) 0, U32V_1(size + 5), 4, 'l', 'u', 'l', 'z'
#define SECTION(name, size) k##name##SectionCode, U32V_1(size)
#define SIGNATURES_SECTION(count, ...) \
SECTION(Type, 1 + 3 * (count)), U32V_1(count), __VA_ARGS__
#define FUNCTION_SIGNATURES_SECTION(count, ...) \
SECTION(Function, 1 + (count)), U32V_1(count), __VA_ARGS__
#define FOO_STRING 3, 'f', 'o', 'o'
#define NO_LOCAL_NAMES 0
#define EMPTY_SIGNATURES_SECTION SECTION(Type, 1), 0
#define EMPTY_FUNCTION_SIGNATURES_SECTION SECTION(Function, 1), 0
#define EMPTY_FUNCTION_BODIES_SECTION SECTION(Code, 1), 0
#define SECTION_NAMES(size) SECTION(Unknown, size + 5), 4, 'n', 'a', 'm', 'e'
#define EMPTY_NAMES_SECTION SECTION_NAMES(1), 0
#define X1(...) __VA_ARGS__
#define X2(...) __VA_ARGS__, __VA_ARGS__
#define X3(...) __VA_ARGS__, __VA_ARGS__, __VA_ARGS__
#define X4(...) __VA_ARGS__, __VA_ARGS__, __VA_ARGS__, __VA_ARGS__
#define ONE_EMPTY_FUNCTION SECTION(Function, 1 + 1 * 1), 1, X1(0)
#define TWO_EMPTY_FUNCTIONS SECTION(Function, 1 + 2 * 1), 2, X2(0)
#define THREE_EMPTY_FUNCTIONS SECTION(Function, 1 + 3 * 1), 3, X3(0)
#define FOUR_EMPTY_FUNCTIONS SECTION(Function, 1 + 4 * 1), 4, X4(0)
#define ONE_EMPTY_BODY \
SECTION(Code, 1 + 1 * (1 + SIZEOF_EMPTY_BODY)) \
, 1, X1(SIZEOF_EMPTY_BODY, EMPTY_BODY)
#define TWO_EMPTY_BODIES \
SECTION(Code, 1 + 2 * (1 + SIZEOF_EMPTY_BODY)) \
, 2, X2(SIZEOF_EMPTY_BODY, EMPTY_BODY)
#define THREE_EMPTY_BODIES \
SECTION(Code, 1 + 3 * (1 + SIZEOF_EMPTY_BODY)) \
, 3, X3(SIZEOF_EMPTY_BODY, EMPTY_BODY)
#define FOUR_EMPTY_BODIES \
SECTION(Code, 1 + 4 * (1 + SIZEOF_EMPTY_BODY)) \
, 4, X4(SIZEOF_EMPTY_BODY, EMPTY_BODY)
#define SIGNATURES_SECTION_VOID_VOID \
SECTION(Type, 1 + SIZEOF_SIG_ENTRY_v_v), 1, SIG_ENTRY_v_v
#define LINEAR_MEMORY_INDEX_0 0
#define EXPECT_VERIFIES(data) \
do { \
ModuleResult result = DecodeModule(data, data + sizeof(data)); \
EXPECT_TRUE(result.ok()); \
} while (false)
#define EXPECT_FAILURE_LEN(data, length) \
do { \
ModuleResult result = DecodeModule(data, data + length); \
EXPECT_FALSE(result.ok()); \
} while (false)
#define EXPECT_FAILURE(data) EXPECT_FAILURE_LEN(data, sizeof(data))
#define EXPECT_OFF_END_FAILURE(data, min, max) \
do { \
for (size_t length = min; length < max; length++) { \
EXPECT_FAILURE_LEN(data, length); \
} \
} while (false)
#define EXPECT_OK(result) \
do { \
EXPECT_TRUE(result.ok()); \
if (!result.ok()) return; \
} while (false)
static size_t SizeOfVarInt(size_t value) {
size_t size = 0;
do {
size++;
value = value >> 7;
} while (value > 0);
return size;
}
struct ValueTypePair {
uint8_t code;
ValueType type;
} kValueTypes[] = {{kLocalI32, kWasmI32},
{kLocalI64, kWasmI64},
{kLocalF32, kWasmF32},
{kLocalF64, kWasmF64}};
class WasmModuleVerifyTest : public TestWithIsolateAndZone {
public:
ModuleResult DecodeModule(const byte* module_start, const byte* module_end) {
// Add the WASM magic and version number automatically.
size_t size = static_cast<size_t>(module_end - module_start);
byte header[] = {WASM_MODULE_HEADER};
size_t total = sizeof(header) + size;
auto temp = new byte[total];
memcpy(temp, header, sizeof(header));
memcpy(temp + sizeof(header), module_start, size);
ModuleResult result =
DecodeWasmModule(isolate(), temp, temp + total, false, kWasmOrigin);
delete[] temp;
return result;
}
ModuleResult DecodeModuleNoHeader(const byte* module_start,
const byte* module_end) {
return DecodeWasmModule(isolate(), module_start, module_end, false,
kWasmOrigin);
}
};
TEST_F(WasmModuleVerifyTest, WrongMagic) {
for (uint32_t x = 1; x; x <<= 1) {
const byte data[] = {U32_LE(kWasmMagic ^ x), U32_LE(kWasmVersion)};
ModuleResult result = DecodeModuleNoHeader(data, data + sizeof(data));
EXPECT_FALSE(result.ok());
}
}
TEST_F(WasmModuleVerifyTest, WrongVersion) {
for (uint32_t x = 1; x; x <<= 1) {
const byte data[] = {U32_LE(kWasmMagic), U32_LE(kWasmVersion ^ x)};
ModuleResult result = DecodeModuleNoHeader(data, data + sizeof(data));
EXPECT_FALSE(result.ok());
}
}
TEST_F(WasmModuleVerifyTest, DecodeEmpty) {
ModuleResult result = DecodeModule(nullptr, 0);
EXPECT_TRUE(result.ok());
}
TEST_F(WasmModuleVerifyTest, OneGlobal) {
static const byte data[] = {
SECTION(Global, 6), // --
1,
kLocalI32, // local type
0, // immutable
WASM_INIT_EXPR_I32V_1(13) // init
};
{
// Should decode to exactly one global.
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(1u, result.val->globals.size());
EXPECT_EQ(0u, result.val->functions.size());
EXPECT_EQ(0u, result.val->data_segments.size());
const WasmGlobal* global = &result.val->globals.back();
EXPECT_EQ(kWasmI32, global->type);
EXPECT_EQ(0u, global->offset);
EXPECT_FALSE(global->mutability);
EXPECT_EQ(WasmInitExpr::kI32Const, global->init.kind);
EXPECT_EQ(13, global->init.val.i32_const);
}
EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
}
TEST_F(WasmModuleVerifyTest, Global_invalid_type) {
static const byte data[] = {
SECTION(Global, 6), // --
1,
64, // invalid memory type
1, // mutable
WASM_INIT_EXPR_I32V_1(33), // init
};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_FALSE(result.ok());
}
TEST_F(WasmModuleVerifyTest, Global_invalid_type2) {
static const byte data[] = {
SECTION(Global, 6), // --
1,
kLocalVoid, // invalid memory type
1, // mutable
WASM_INIT_EXPR_I32V_1(33), // init
};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_FALSE(result.ok());
}
TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
static const byte data[] = {
SECTION(Global, 1), // --
0, // declare 0 globals
};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
}
TEST_F(WasmModuleVerifyTest, ExportMutableGlobal) {
{
static const byte data[] = {
SECTION(Global, 6), // --
1,
kLocalI32, // local type
0, // immutable
WASM_INIT_EXPR_I32V_1(13), // init
SECTION(Export, 8), // --
1, // Export count
4, // name length
'n', // --
'a', // --
'm', // --
'e', // --
kExternalGlobal, // global
0, // global index
};
EXPECT_VERIFIES(data);
}
{
static const byte data[] = {
SECTION(Global, 6), // --
1, // --
kLocalI32, // local type
1, // mutable
WASM_INIT_EXPR_I32V_1(13), // init
SECTION(Export, 8), // --
1, // Export count
4, // name length
'n', // --
'a', // --
'm', // --
'e', // --
kExternalGlobal, // global
0, // global index
};
EXPECT_FAILURE(data);
}
}
static void AppendUint32v(std::vector<byte>& buffer, uint32_t val) {
while (true) {
uint32_t next = val >> 7;
uint32_t out = val & 0x7f;
if (next) {
buffer.push_back(static_cast<byte>(0x80 | out));
val = next;
} else {
buffer.push_back(static_cast<byte>(out));
break;
}
}
}
TEST_F(WasmModuleVerifyTest, NGlobals) {
static const byte data[] = {
kLocalF32, // memory type
0, // immutable
WASM_INIT_EXPR_F32(7.7), // init
};
for (uint32_t i = 0; i < kV8MaxWasmGlobals; i = i * 13 + 1) {
std::vector<byte> buffer;
size_t size = SizeOfVarInt(i) + i * sizeof(data);
const byte globals[] = {kGlobalSectionCode, U32V_5(size)};
for (size_t g = 0; g != sizeof(globals); ++g) {
buffer.push_back(globals[g]);
}
AppendUint32v(buffer, i); // Number of globals.
for (uint32_t j = 0; j < i; j++) {
buffer.insert(buffer.end(), data, data + sizeof(data));
}
ModuleResult result = DecodeModule(&buffer[0], &buffer[0] + buffer.size());
EXPECT_OK(result);
}
}
TEST_F(WasmModuleVerifyTest, GlobalWithInvalidMemoryType) {
static const byte data[] = {SECTION(Global, 7),
33, // memory type
0, // exported
WASM_INIT_EXPR_I32V_1(1)};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, TwoGlobals) {
static const byte data[] = {
SECTION(Global, 21),
2,
kLocalF32, // type
0, // immutable
WASM_INIT_EXPR_F32(22.0),
kLocalF64, // type
1, // mutable
WASM_INIT_EXPR_F64(23.0),
};
{
// Should decode to exactly two globals.
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(2u, result.val->globals.size());
EXPECT_EQ(0u, result.val->functions.size());
EXPECT_EQ(0u, result.val->data_segments.size());
const WasmGlobal* g0 = &result.val->globals[0];
EXPECT_EQ(kWasmF32, g0->type);
EXPECT_EQ(0u, g0->offset);
EXPECT_FALSE(g0->mutability);
EXPECT_EQ(WasmInitExpr::kF32Const, g0->init.kind);
const WasmGlobal* g1 = &result.val->globals[1];
EXPECT_EQ(kWasmF64, g1->type);
EXPECT_EQ(8u, g1->offset);
EXPECT_TRUE(g1->mutability);
EXPECT_EQ(WasmInitExpr::kF64Const, g1->init.kind);
}
EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
}
TEST_F(WasmModuleVerifyTest, OneSignature) {
{
static const byte data[] = {SIGNATURES_SECTION_VOID_VOID};
EXPECT_VERIFIES(data);
}
{
static const byte data[] = {SECTION(Type, 1 + SIZEOF_SIG_ENTRY_x_x), 1,
SIG_ENTRY_i_i};
EXPECT_VERIFIES(data);
}
}
TEST_F(WasmModuleVerifyTest, MultipleSignatures) {
static const byte data[] = {
SECTION(Type, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_x_x +
SIZEOF_SIG_ENTRY_x_xx), // --
3, // --
SIG_ENTRY_v_v, // void -> void
SIG_ENTRY_x_x(kLocalI32, kLocalF32), // f32 -> i32
SIG_ENTRY_x_xx(kLocalI32, kLocalF64, kLocalF64), // f64,f64 -> i32
};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(3u, result.val->signatures.size());
if (result.val->signatures.size() == 3) {
EXPECT_EQ(0u, result.val->signatures[0]->return_count());
EXPECT_EQ(1u, result.val->signatures[1]->return_count());
EXPECT_EQ(1u, result.val->signatures[2]->return_count());
EXPECT_EQ(0u, result.val->signatures[0]->parameter_count());
EXPECT_EQ(1u, result.val->signatures[1]->parameter_count());
EXPECT_EQ(2u, result.val->signatures[2]->parameter_count());
}
EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
}
TEST_F(WasmModuleVerifyTest, DataSegmentWithImmutableImportedGlobal) {
// Import 2 globals so that we can initialize data with a global index != 0.
const byte data[] = {
SECTION(Import, 15), // section header
2, // number of imports
NAME_LENGTH(1), // --
'm', // module name
NAME_LENGTH(1), // --
'f', // global name
kExternalGlobal, // import kind
kLocalI32, // type
0, // mutability
NAME_LENGTH(1), // --
'n', // module name
NAME_LENGTH(1), // --
'g', // global name
kExternalGlobal, // import kind
kLocalI32, // type
0, // mutability
SECTION(Memory, 4),
ENTRY_COUNT(1),
kResizableMaximumFlag,
28,
28,
SECTION(Data, 9),
ENTRY_COUNT(1),
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_GLOBAL(1), // dest addr
U32V_1(3), // source size
'a',
'b',
'c' // data bytes
};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
WasmInitExpr expr = result.val->data_segments.back().dest_addr;
EXPECT_EQ(WasmInitExpr::kGlobalIndex, expr.kind);
EXPECT_EQ(1u, expr.val.global_index);
}
TEST_F(WasmModuleVerifyTest, DataSegmentWithMutableImportedGlobal) {
// Only an immutable imported global can be used as an init_expr.
const byte data[] = {
SECTION(Import, 8), // section header
1, // number of imports
NAME_LENGTH(1), // --
'm', // module name
NAME_LENGTH(1), // --
'f', // global name
kExternalGlobal, // import kind
kLocalI32, // type
1, // mutability
SECTION(Memory, 4),
ENTRY_COUNT(1),
kResizableMaximumFlag,
28,
28,
SECTION(Data, 9),
ENTRY_COUNT(1),
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_GLOBAL(0), // dest addr
U32V_1(3), // source size
'a',
'b',
'c' // data bytes
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, DataSegmentWithImmutableGlobal) {
// Only an immutable imported global can be used as an init_expr.
const byte data[] = {
SECTION(Memory, 4),
ENTRY_COUNT(1),
kResizableMaximumFlag,
28,
28,
SECTION(Global, 8), // --
1,
kLocalI32, // local type
0, // immutable
WASM_INIT_EXPR_I32V_3(0x9bbaa), // init
SECTION(Data, 9),
ENTRY_COUNT(1),
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_GLOBAL(0), // dest addr
U32V_1(3), // source size
'a',
'b',
'c' // data bytes
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, OneDataSegment) {
const byte kDataSegmentSourceOffset = 24;
const byte data[] = {
SECTION(Memory, 4),
ENTRY_COUNT(1),
kResizableMaximumFlag,
28,
28,
SECTION(Data, 11),
ENTRY_COUNT(1),
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_I32V_3(0x9bbaa), // dest addr
U32V_1(3), // source size
'a',
'b',
'c' // data bytes
};
{
EXPECT_VERIFIES(data);
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(0u, result.val->globals.size());
EXPECT_EQ(0u, result.val->functions.size());
EXPECT_EQ(1u, result.val->data_segments.size());
const WasmDataSegment* segment = &result.val->data_segments.back();
EXPECT_EQ(WasmInitExpr::kI32Const, segment->dest_addr.kind);
EXPECT_EQ(0x9bbaa, segment->dest_addr.val.i32_const);
EXPECT_EQ(kDataSegmentSourceOffset, segment->source_offset);
EXPECT_EQ(3u, segment->source_size);
}
EXPECT_OFF_END_FAILURE(data, 14, sizeof(data));
}
TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
const byte kDataSegment0SourceOffset = 24;
const byte kDataSegment1SourceOffset = kDataSegment0SourceOffset + 11;
const byte data[] = {
SECTION(Memory, 4),
ENTRY_COUNT(1),
kResizableMaximumFlag,
28,
28,
SECTION(Data, 29),
ENTRY_COUNT(2), // segment count
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_I32V_3(0x7ffee), // #0: dest addr
U32V_1(4), // source size
1,
2,
3,
4, // data bytes
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_I32V_3(0x6ddcc), // #1: dest addr
U32V_1(10), // source size
1,
2,
3,
4,
5,
6,
7,
8,
9,
10 // data bytes
};
{
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(0u, result.val->globals.size());
EXPECT_EQ(0u, result.val->functions.size());
EXPECT_EQ(2u, result.val->data_segments.size());
const WasmDataSegment* s0 = &result.val->data_segments[0];
const WasmDataSegment* s1 = &result.val->data_segments[1];
EXPECT_EQ(WasmInitExpr::kI32Const, s0->dest_addr.kind);
EXPECT_EQ(0x7ffee, s0->dest_addr.val.i32_const);
EXPECT_EQ(kDataSegment0SourceOffset, s0->source_offset);
EXPECT_EQ(4u, s0->source_size);
EXPECT_EQ(WasmInitExpr::kI32Const, s1->dest_addr.kind);
EXPECT_EQ(0x6ddcc, s1->dest_addr.val.i32_const);
EXPECT_EQ(kDataSegment1SourceOffset, s1->source_offset);
EXPECT_EQ(10u, s1->source_size);
}
EXPECT_OFF_END_FAILURE(data, 14, sizeof(data));
}
TEST_F(WasmModuleVerifyTest, DataWithoutMemory) {
const byte data[] = {
SECTION(Data, 11),
ENTRY_COUNT(1),
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_I32V_3(0x9bbaa), // dest addr
U32V_1(3), // source size
'a',
'b',
'c' // data bytes
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, MaxMaximumMemorySize) {
{
const byte data[] = {
SECTION(Memory, 6), ENTRY_COUNT(1), kResizableMaximumFlag, 0,
U32V_3(65536),
};
EXPECT_VERIFIES(data);
}
{
const byte data[] = {
SECTION(Memory, 6), ENTRY_COUNT(1), kResizableMaximumFlag, 0,
U32V_3(65537),
};
EXPECT_FAILURE(data);
}
}
TEST_F(WasmModuleVerifyTest, DataSegment_wrong_init_type) {
const byte data[] = {
SECTION(Memory, 4),
ENTRY_COUNT(1),
kResizableMaximumFlag,
28,
28,
SECTION(Data, 11),
ENTRY_COUNT(1),
LINEAR_MEMORY_INDEX_0,
WASM_INIT_EXPR_F64(9.9), // dest addr
U32V_1(3), // source size
'a',
'b',
'c' // data bytes
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, OneIndirectFunction) {
static const byte data[] = {
// sig#0 ---------------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
// funcs ---------------------------------------------------------------
ONE_EMPTY_FUNCTION,
// table declaration ---------------------------------------------------
SECTION(Table, 4), ENTRY_COUNT(1), kWasmAnyFunctionTypeForm, 0, 1};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
if (result.ok()) {
EXPECT_EQ(1u, result.val->signatures.size());
EXPECT_EQ(1u, result.val->functions.size());
EXPECT_EQ(1u, result.val->function_tables.size());
EXPECT_EQ(1u, result.val->function_tables[0].min_size);
}
}
TEST_F(WasmModuleVerifyTest, OneIndirectFunction_one_entry) {
static const byte data[] = {
// sig#0 ---------------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
// funcs ---------------------------------------------------------------
ONE_EMPTY_FUNCTION,
// table declaration ---------------------------------------------------
SECTION(Table, 4), ENTRY_COUNT(1), kWasmAnyFunctionTypeForm, 0, 1,
// elements ------------------------------------------------------------
SECTION(Element, 7),
1, // entry count
TABLE_INDEX(0), WASM_INIT_EXPR_I32V_1(0),
1, // elements count
FUNC_INDEX(0)};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
if (result.ok()) {
EXPECT_EQ(1u, result.val->signatures.size());
EXPECT_EQ(1u, result.val->functions.size());
EXPECT_EQ(1u, result.val->function_tables.size());
EXPECT_EQ(1u, result.val->function_tables[0].min_size);
}
}
TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
static const byte data[] = {
// sig#0 -------------------------------------------------------
SECTION(Type, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_v_x),
2, // --
SIG_ENTRY_v_v, // void -> void
SIG_ENTRY_v_x(kLocalI32), // void -> i32
// funcs ------------------------------------------------------
FOUR_EMPTY_FUNCTIONS,
// table declaration -------------------------------------------
SECTION(Table, 4), ENTRY_COUNT(1), kWasmAnyFunctionTypeForm, 0, 8,
// table elements ----------------------------------------------
SECTION(Element, 14),
1, // entry count
TABLE_INDEX(0), WASM_INIT_EXPR_I32V_1(0),
8, // elements count
FUNC_INDEX(0), // --
FUNC_INDEX(1), // --
FUNC_INDEX(2), // --
FUNC_INDEX(3), // --
FUNC_INDEX(0), // --
FUNC_INDEX(1), // --
FUNC_INDEX(2), // --
FUNC_INDEX(3), // --
FOUR_EMPTY_BODIES};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
if (result.ok()) {
EXPECT_EQ(2u, result.val->signatures.size());
EXPECT_EQ(4u, result.val->functions.size());
EXPECT_EQ(1u, result.val->function_tables.size());
EXPECT_EQ(8u, result.val->function_tables[0].min_size);
}
}
TEST_F(WasmModuleVerifyTest, IndirectFunctionNoFunctions) {
static const byte data[] = {
// sig#0 -------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
// indirect table ----------------------------------------------
SECTION(Table, 4), ENTRY_COUNT(1), 1, 0, 0,
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, IndirectFunctionInvalidIndex) {
static const byte data[] = {
// sig#0 -------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
// functions ---------------------------------------------------
ONE_EMPTY_FUNCTION,
// indirect table ----------------------------------------------
SECTION(Table, 4), ENTRY_COUNT(1), 1, 1, 0,
};
EXPECT_FAILURE(data);
}
class WasmSignatureDecodeTest : public TestWithZone {};
TEST_F(WasmSignatureDecodeTest, Ok_v_v) {
static const byte data[] = {SIG_ENTRY_v_v};
v8::internal::AccountingAllocator allocator;
Zone zone(&allocator, ZONE_NAME);
FunctionSig* sig =
DecodeWasmSignatureForTesting(&zone, data, data + sizeof(data));
EXPECT_TRUE(sig != nullptr);
EXPECT_EQ(0u, sig->parameter_count());
EXPECT_EQ(0u, sig->return_count());
}
TEST_F(WasmSignatureDecodeTest, Ok_t_v) {
for (size_t i = 0; i < arraysize(kValueTypes); i++) {
ValueTypePair ret_type = kValueTypes[i];
const byte data[] = {SIG_ENTRY_x(ret_type.code)};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_TRUE(sig != nullptr);
EXPECT_EQ(0u, sig->parameter_count());
EXPECT_EQ(1u, sig->return_count());
EXPECT_EQ(ret_type.type, sig->GetReturn());
}
}
TEST_F(WasmSignatureDecodeTest, Ok_v_t) {
for (size_t i = 0; i < arraysize(kValueTypes); i++) {
ValueTypePair param_type = kValueTypes[i];
const byte data[] = {SIG_ENTRY_v_x(param_type.code)};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_TRUE(sig != nullptr);
EXPECT_EQ(1u, sig->parameter_count());
EXPECT_EQ(0u, sig->return_count());
EXPECT_EQ(param_type.type, sig->GetParam(0));
}
}
TEST_F(WasmSignatureDecodeTest, Ok_t_t) {
for (size_t i = 0; i < arraysize(kValueTypes); i++) {
ValueTypePair ret_type = kValueTypes[i];
for (size_t j = 0; j < arraysize(kValueTypes); j++) {
ValueTypePair param_type = kValueTypes[j];
const byte data[] = {SIG_ENTRY_x_x(ret_type.code, param_type.code)};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_TRUE(sig != nullptr);
EXPECT_EQ(1u, sig->parameter_count());
EXPECT_EQ(1u, sig->return_count());
EXPECT_EQ(param_type.type, sig->GetParam(0));
EXPECT_EQ(ret_type.type, sig->GetReturn());
}
}
}
TEST_F(WasmSignatureDecodeTest, Ok_i_tt) {
for (size_t i = 0; i < arraysize(kValueTypes); i++) {
ValueTypePair p0_type = kValueTypes[i];
for (size_t j = 0; j < arraysize(kValueTypes); j++) {
ValueTypePair p1_type = kValueTypes[j];
const byte data[] = {
SIG_ENTRY_x_xx(kLocalI32, p0_type.code, p1_type.code)};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_TRUE(sig != nullptr);
EXPECT_EQ(2u, sig->parameter_count());
EXPECT_EQ(1u, sig->return_count());
EXPECT_EQ(p0_type.type, sig->GetParam(0));
EXPECT_EQ(p1_type.type, sig->GetParam(1));
}
}
}
TEST_F(WasmSignatureDecodeTest, TooManyParams) {
static const byte data[] = {kWasmFunctionTypeForm,
WASM_I32V_3(kV8MaxWasmFunctionParams + 1),
kLocalI32, 0};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_FALSE(sig != nullptr);
}
TEST_F(WasmSignatureDecodeTest, TooManyReturns) {
for (int i = 0; i < 2; i++) {
EnableFlagScope flag_scope(&FLAG_experimental_wasm_mv, i != 0);
const int max_return_count = static_cast<int>(
FLAG_experimental_wasm_mv ? kV8MaxWasmFunctionMultiReturns
: kV8MaxWasmFunctionReturns);
byte data[] = {kWasmFunctionTypeForm, 0, WASM_I32V_3(max_return_count + 1),
kLocalI32};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_EQ(nullptr, sig);
}
}
TEST_F(WasmSignatureDecodeTest, Fail_off_end) {
byte data[256];
for (int p = 0; p <= 255; p = p + 1 + p * 3) {
for (int i = 0; i <= p; i++) data[i] = kLocalI32;
data[0] = static_cast<byte>(p);
for (int i = 0; i < p + 1; i++) {
// Should fall off the end for all signatures.
FunctionSig* sig = DecodeWasmSignatureForTesting(zone(), data, data + i);
EXPECT_EQ(nullptr, sig);
}
}
}
TEST_F(WasmSignatureDecodeTest, Fail_invalid_type) {
byte kInvalidType = 76;
for (size_t i = 0; i < SIZEOF_SIG_ENTRY_x_xx; i++) {
byte data[] = {SIG_ENTRY_x_xx(kLocalI32, kLocalI32, kLocalI32)};
data[i] = kInvalidType;
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_EQ(nullptr, sig);
}
}
TEST_F(WasmSignatureDecodeTest, Fail_invalid_ret_type1) {
static const byte data[] = {SIG_ENTRY_x_x(kLocalVoid, kLocalI32)};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_EQ(nullptr, sig);
}
TEST_F(WasmSignatureDecodeTest, Fail_invalid_param_type1) {
static const byte data[] = {SIG_ENTRY_x_x(kLocalI32, kLocalVoid)};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_EQ(nullptr, sig);
}
TEST_F(WasmSignatureDecodeTest, Fail_invalid_param_type2) {
static const byte data[] = {SIG_ENTRY_x_xx(kLocalI32, kLocalI32, kLocalVoid)};
FunctionSig* sig =
DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
EXPECT_EQ(nullptr, sig);
}
class WasmFunctionVerifyTest : public TestWithIsolateAndZone {
public:
WasmFunctionVerifyTest()
: instance(&module), env(&module, &instance, bytes) {}
virtual ~WasmFunctionVerifyTest() {}
ModuleBytesEnv* get_env() { return &env; }
private:
WasmModule module;
WasmInstance instance;
Vector<const byte> bytes;
ModuleBytesEnv env;
DISALLOW_COPY_AND_ASSIGN(WasmFunctionVerifyTest);
};
TEST_F(WasmFunctionVerifyTest, Ok_v_v_empty) {
static const byte data[] = {
SIG_ENTRY_v_v, // signature entry
4, // locals
3,
kLocalI32, // --
4,
kLocalI64, // --
5,
kLocalF32, // --
6,
kLocalF64, // --
kExprEnd // body
};
FunctionResult result = DecodeWasmFunction(isolate(), zone(), get_env(), data,
data + sizeof(data));
EXPECT_OK(result);
if (result.val && result.ok()) {
WasmFunction* function = result.val.get();
EXPECT_EQ(0u, function->sig->parameter_count());
EXPECT_EQ(0u, function->sig->return_count());
EXPECT_EQ(0u, function->name_offset);
EXPECT_EQ(static_cast<uint32_t>(SIZEOF_SIG_ENTRY_v_v),
function->code_start_offset);
EXPECT_EQ(sizeof(data), function->code_end_offset);
// TODO(titzer): verify encoding of local declarations
}
}
TEST_F(WasmModuleVerifyTest, SectionWithoutNameLength) {
const byte data[] = {1};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, TheLoneliestOfValidModulesTheTrulyEmptyOne) {
const byte data[] = {
0, // unknown section code.
0, // Empty section name.
// No section name, no content, nothing but sadness.
0, // No section content.
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, OnlyUnknownSectionEmpty) {
const byte data[] = {
UNKNOWN_SECTION(0),
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, OnlyUnknownSectionNonEmpty) {
const byte data[] = {
UNKNOWN_SECTION(5),
0xff,
0xff,
0xff,
0xff,
0xff, // section data
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, SignatureFollowedByEmptyUnknownSection) {
const byte data[] = {
// signatures
SIGNATURES_SECTION_VOID_VOID,
// -----------------------------------------------------------
UNKNOWN_SECTION(0)};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, SignatureFollowedByUnknownSection) {
const byte data[] = {
// signatures
SIGNATURES_SECTION_VOID_VOID,
// -----------------------------------------------------------
UNKNOWN_SECTION(5), 0xff, 0xff, 0xff, 0xff, 0xff,
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, UnknownSectionOverflow) {
static const byte data[] = {
UNKNOWN_SECTION(9),
1,
2,
3,
4,
5,
6,
7,
8,
9,
10, // 10 byte section
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, UnknownSectionUnderflow) {
static const byte data[] = {
UNKNOWN_SECTION(333),
1,
2,
3,
4, // 4 byte section
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, UnknownSectionSkipped) {
static const byte data[] = {
UNKNOWN_SECTION(1),
0, // one byte section
SECTION(Global, 6),
1,
kLocalI32, // memory type
0, // exported
WASM_INIT_EXPR_I32V_1(33), // init
};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(1u, result.val->globals.size());
EXPECT_EQ(0u, result.val->functions.size());
EXPECT_EQ(0u, result.val->data_segments.size());
const WasmGlobal* global = &result.val->globals.back();
EXPECT_EQ(kWasmI32, global->type);
EXPECT_EQ(0u, global->offset);
}
TEST_F(WasmModuleVerifyTest, ImportTable_empty) {
static const byte data[] = {SECTION(Type, 1), 0, SECTION(Import, 1), 0};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, ImportTable_nosigs1) {
static const byte data[] = {SECTION(Import, 1), 0};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, ImportTable_mutable_global) {
{
static const byte data[] = {
SECTION(Import, 8), // section header
1, // number of imports
NAME_LENGTH(1), // --
'm', // module name
NAME_LENGTH(1), // --
'f', // global name
kExternalGlobal, // import kind
kLocalI32, // type
0, // mutability
};
EXPECT_VERIFIES(data);
}
{
static const byte data[] = {
SECTION(Import, 8), // section header
1, // sig table
NAME_LENGTH(1), // --
'm', // module name
NAME_LENGTH(1), // --
'f', // global name
kExternalGlobal, // import kind
kLocalI32, // type
1, // mutability
};
EXPECT_FAILURE(data);
}
}
TEST_F(WasmModuleVerifyTest, ImportTable_mutability_malformed) {
static const byte data[] = {
SECTION(Import, 8),
1, // --
NAME_LENGTH(1), // --
'm', // module name
NAME_LENGTH(1), // --
'g', // global name
kExternalGlobal, // import kind
kLocalI32, // type
2, // invalid mutability
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, ImportTable_nosigs2) {
static const byte data[] = {
SECTION(Import, 6), 1, // sig table
NAME_LENGTH(1), 'm', // module name
NAME_LENGTH(1), 'f', // function name
kExternalFunction, // import kind
IMPORT_SIG_INDEX(0), // sig index
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, ImportTable_invalid_sig) {
static const byte data[] = {
SECTION(Type, 1), 0, // --
SECTION(Import, 6), 1, // --
NAME_LENGTH(1), 'm', // module name
NAME_LENGTH(1), 'f', // function name
kExternalFunction, // import kind
IMPORT_SIG_INDEX(0), // sig index
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, ImportTable_one_sig) {
static const byte data[] = {
// signatures
SIGNATURES_SECTION_VOID_VOID,
SECTION(Import, 7),
1, // --
NAME_LENGTH(1),
'm', // module name
NAME_LENGTH(1),
'f', // function name
kExternalFunction, // import kind
IMPORT_SIG_INDEX(0), // sig index
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, ImportTable_invalid_module) {
static const byte data[] = {
// signatures
SIGNATURES_SECTION_VOID_VOID, // --
SECTION(Import, 7), // --
1, // --
NO_NAME, // module name
NAME_LENGTH(1), // --
'f', // function name
kExternalFunction, // import kind
IMPORT_SIG_INDEX(0), // sig index
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, ImportTable_off_end) {
static const byte data[] = {
// signatures
SIGNATURES_SECTION_VOID_VOID,
SECTION(Import, 6),
1,
NAME_LENGTH(1),
'm', // module name
NAME_LENGTH(1),
'f', // function name
kExternalFunction, // import kind
IMPORT_SIG_INDEX(0), // sig index
};
EXPECT_OFF_END_FAILURE(data, 16, sizeof(data));
}
TEST_F(WasmModuleVerifyTest, ExportTable_empty1) {
static const byte data[] = { // signatures
SIGNATURES_SECTION_VOID_VOID, // --
ONE_EMPTY_FUNCTION, SECTION(Export, 1), // --
0, // --
ONE_EMPTY_BODY};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(1u, result.val->functions.size());
EXPECT_EQ(0u, result.val->export_table.size());
}
TEST_F(WasmModuleVerifyTest, ExportTable_empty2) {
static const byte data[] = {
SECTION(Type, 1), 0, SECTION(Export, 1), 0 // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, ExportTable_NoFunctions2) {
static const byte data[] = {SECTION(Export, 1), 0};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, ExportTableOne) {
static const byte data[] = {// signatures
SIGNATURES_SECTION_VOID_VOID,
ONE_EMPTY_FUNCTION,
SECTION(Export, 4),
1, // exports
NO_NAME, // --
kExternalFunction, // --
FUNC_INDEX(0), // --
ONE_EMPTY_BODY};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(1u, result.val->functions.size());
EXPECT_EQ(1u, result.val->export_table.size());
}
TEST_F(WasmModuleVerifyTest, ExportNameWithInvalidStringLength) {
static const byte data[] = {// signatures
SIGNATURES_SECTION_VOID_VOID,
ONE_EMPTY_FUNCTION,
SECTION(Export, 12),
1, // exports
NAME_LENGTH(84), // invalid string length
'e', // --
kExternalFunction, // --
FUNC_INDEX(0)};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, ExportTableTwo) {
static const byte data[] = {// signatures
SIGNATURES_SECTION_VOID_VOID,
ONE_EMPTY_FUNCTION,
SECTION(Export, 14),
2, // exports
NAME_LENGTH(4),
'n',
'a',
'm',
'e', // --
kExternalFunction,
FUNC_INDEX(0), // --
NAME_LENGTH(3),
'n',
'o',
'm', // --
kExternalFunction, // --
FUNC_INDEX(0), // --
ONE_EMPTY_BODY};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(1u, result.val->functions.size());
EXPECT_EQ(2u, result.val->export_table.size());
}
TEST_F(WasmModuleVerifyTest, ExportTableThree) {
static const byte data[] = {// signatures
SIGNATURES_SECTION_VOID_VOID,
THREE_EMPTY_FUNCTIONS,
SECTION(Export, 13),
3, // exports
NAME_LENGTH(1),
'a', // --
kExternalFunction,
FUNC_INDEX(0), // --
NAME_LENGTH(1),
'b', // --
kExternalFunction,
FUNC_INDEX(1), // --
NAME_LENGTH(1),
'c', // --
kExternalFunction,
FUNC_INDEX(2), // --
THREE_EMPTY_BODIES};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(3u, result.val->functions.size());
EXPECT_EQ(3u, result.val->export_table.size());
}
TEST_F(WasmModuleVerifyTest, ExportTableThreeOne) {
for (int i = 0; i < 6; i++) {
const byte data[] = {// signatures
SIGNATURES_SECTION_VOID_VOID,
THREE_EMPTY_FUNCTIONS,
SECTION(Export, 6),
1, // exports
NAME_LENGTH(2),
'e',
'x', // --
kExternalFunction,
FUNC_INDEX(i), // --
THREE_EMPTY_BODIES};
if (i < 3) {
EXPECT_VERIFIES(data);
} else {
EXPECT_FAILURE(data);
}
}
}
TEST_F(WasmModuleVerifyTest, ExportTableOne_off_end) {
static const byte data[] = {
// signatures
SIGNATURES_SECTION_VOID_VOID,
ONE_EMPTY_FUNCTION,
SECTION(Export, 1 + 6),
1, // exports
NO_NAME, // --
kExternalFunction,
FUNC_INDEX(0), // --
};
for (size_t length = 33; length < sizeof(data); length++) {
ModuleResult result = DecodeModule(data, data + length);
EXPECT_FALSE(result.ok());
}
}
TEST_F(WasmModuleVerifyTest, FunctionSignatures_empty) {
static const byte data[] = {
SECTION(Type, 1), 0, // --
SECTION(Function, 1), 0 // --
}; // --
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, FunctionSignatures_one) {
static const byte data[] = {
SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
FUNCTION_SIGNATURES_SECTION(1, 0) // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, Regression_648070) {
static const byte data[] = {
SECTION(Type, 1), 0, // --
SECTION(Function, 5), // --
U32V_5(3500228624) // function count = 3500228624
}; // --
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, FunctionBodies_empty) {
static const byte data[] = {
EMPTY_SIGNATURES_SECTION, // --
EMPTY_FUNCTION_SIGNATURES_SECTION, // --
EMPTY_FUNCTION_BODIES_SECTION // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, FunctionBodies_one_empty) {
static const byte data[] = {
SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
FUNCTION_SIGNATURES_SECTION(1, 0), // --
SECTION(Code, 1 + SIZEOF_EMPTY_BODY), 1, EMPTY_BODY // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, FunctionBodies_one_nop) {
static const byte data[] = {
SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
FUNCTION_SIGNATURES_SECTION(1, 0), // --
SECTION(Code, 1 + SIZEOF_NOP_BODY), 1, NOP_BODY // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, FunctionBodies_count_mismatch1) {
static const byte data[] = {
SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
FUNCTION_SIGNATURES_SECTION(2, 0, 0), // --
SECTION(Code, 1 + SIZEOF_EMPTY_BODY), 1, // --
EMPTY_BODY // --
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, FunctionBodies_count_mismatch2) {
static const byte data[] = {
SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
FUNCTION_SIGNATURES_SECTION(1, 0), // --
SECTION(Code, 1 + 2 * SIZEOF_NOP_BODY), // --
ENTRY_COUNT(2), // --
NOP_BODY, // --
NOP_BODY // --
};
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, Names_empty) {
static const byte data[] = {
EMPTY_SIGNATURES_SECTION, EMPTY_FUNCTION_SIGNATURES_SECTION,
EMPTY_FUNCTION_BODIES_SECTION, EMPTY_NAMES_SECTION};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, Names_one_empty) {
static const byte data[] = {
SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
FUNCTION_SIGNATURES_SECTION(1, 0), // --
SECTION(Code, 1 + SIZEOF_EMPTY_BODY),
ENTRY_COUNT(1),
EMPTY_BODY, // --
SECTION_NAMES(1 + 5),
ENTRY_COUNT(1),
FOO_STRING,
NO_LOCAL_NAMES // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, Names_two_empty) {
static const byte data[] = {
SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
FUNCTION_SIGNATURES_SECTION(2, 0, 0), // --
SECTION(Code, 1 + 2 * SIZEOF_EMPTY_BODY), // --
ENTRY_COUNT(2),
EMPTY_BODY,
EMPTY_BODY, // --
SECTION_NAMES(1 + 10),
ENTRY_COUNT(2), // --
FOO_STRING,
NO_LOCAL_NAMES, // --
FOO_STRING,
NO_LOCAL_NAMES, // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, Regression684855) {
static const byte data[] = {
SECTION_NAMES(12),
0xfb, // functions count
0x27, // |
0x00, // function name length
0xff, // local names count
0xff, // |
0xff, // |
0xff, // |
0xff, // |
0xff, // error: "varint too large"
0xff, // |
0x00, // --
0x00 // --
};
EXPECT_VERIFIES(data);
}
#define EXPECT_INIT_EXPR(Type, type, value, ...) \
{ \
static const byte data[] = {__VA_ARGS__, kExprEnd}; \
WasmInitExpr expr = \
DecodeWasmInitExprForTesting(data, data + sizeof(data)); \
EXPECT_EQ(WasmInitExpr::k##Type##Const, expr.kind); \
EXPECT_EQ(value, expr.val.type##_const); \
}
TEST_F(WasmModuleVerifyTest, InitExpr_i32) {
EXPECT_INIT_EXPR(I32, i32, 33, WASM_I32V_1(33));
EXPECT_INIT_EXPR(I32, i32, -21, WASM_I32V_1(-21));
EXPECT_INIT_EXPR(I32, i32, 437, WASM_I32V_2(437));
EXPECT_INIT_EXPR(I32, i32, 77777, WASM_I32V_3(77777));
}
TEST_F(WasmModuleVerifyTest, InitExpr_f32) {
EXPECT_INIT_EXPR(F32, f32, static_cast<float>(13.1), WASM_F32(13.1));
EXPECT_INIT_EXPR(F32, f32, static_cast<float>(-21.1), WASM_F32(-21.1));
EXPECT_INIT_EXPR(F32, f32, static_cast<float>(437.2), WASM_F32(437.2));
EXPECT_INIT_EXPR(F32, f32, static_cast<float>(77777.3), WASM_F32(77777.3));
}
TEST_F(WasmModuleVerifyTest, InitExpr_i64) {
EXPECT_INIT_EXPR(I64, i64, 33, WASM_I64V_1(33));
EXPECT_INIT_EXPR(I64, i64, -21, WASM_I64V_2(-21));
EXPECT_INIT_EXPR(I64, i64, 437, WASM_I64V_5(437));
EXPECT_INIT_EXPR(I64, i64, 77777, WASM_I64V_7(77777));
}
TEST_F(WasmModuleVerifyTest, InitExpr_f64) {
EXPECT_INIT_EXPR(F64, f64, 83.22, WASM_F64(83.22));
EXPECT_INIT_EXPR(F64, f64, -771.3, WASM_F64(-771.3));
EXPECT_INIT_EXPR(F64, f64, 43703.0, WASM_F64(43703.0));
EXPECT_INIT_EXPR(F64, f64, 77999.1, WASM_F64(77999.1));
}
#define EXPECT_INIT_EXPR_FAIL(...) \
{ \
static const byte data[] = {__VA_ARGS__, kExprEnd}; \
WasmInitExpr expr = \
DecodeWasmInitExprForTesting(data, data + sizeof(data)); \
EXPECT_EQ(WasmInitExpr::kNone, expr.kind); \
}
TEST_F(WasmModuleVerifyTest, InitExpr_illegal) {
EXPECT_INIT_EXPR_FAIL(WASM_I32V_1(0), WASM_I32V_1(0));
EXPECT_INIT_EXPR_FAIL(WASM_GET_LOCAL(0));
EXPECT_INIT_EXPR_FAIL(WASM_SET_LOCAL(0, WASM_I32V_1(0)));
EXPECT_INIT_EXPR_FAIL(WASM_I32_ADD(WASM_I32V_1(0), WASM_I32V_1(0)));
EXPECT_INIT_EXPR_FAIL(WASM_IF_ELSE(WASM_ZERO, WASM_ZERO, WASM_ZERO));
}
TEST_F(WasmModuleVerifyTest, Multiple_Named_Sections) {
static const byte data[] = {
SECTION(Unknown, 4), 1, 'X', 17, 18, // --
SECTION(Unknown, 9), 3, 'f', 'o', 'o', 5, 6, 7, 8, 9, // --
SECTION(Unknown, 8), 5, 'o', 't', 'h', 'e', 'r', 7, 8, // --
};
EXPECT_VERIFIES(data);
}
TEST_F(WasmModuleVerifyTest, Section_Name_No_UTF8) {
static const byte data[] = {SECTION(Unknown, 4), 1, 0xff, 17, 18};
EXPECT_FAILURE(data);
}
class WasmModuleCustomSectionTest : public TestWithIsolateAndZone {
public:
void CheckSections(const byte* module_start, const byte* module_end,
CustomSectionOffset expected[], size_t num_expected) {
// Add the WASM magic and version number automatically.
size_t size = static_cast<size_t>(module_end - module_start);
byte header[] = {WASM_MODULE_HEADER};
size_t total = sizeof(header) + size;
auto temp = new byte[total];
memcpy(temp, header, sizeof(header));
memcpy(temp + sizeof(header), module_start, size);
std::vector<CustomSectionOffset> custom_sections =
DecodeCustomSections(module_start, module_end);
CHECK_EQ(num_expected, custom_sections.size());
for (size_t i = 0; i < num_expected; i++) {
EXPECT_EQ(expected[i].section_start, custom_sections[i].section_start);
EXPECT_EQ(expected[i].name_offset, custom_sections[i].name_offset);
EXPECT_EQ(expected[i].name_length, custom_sections[i].name_length);
EXPECT_EQ(expected[i].payload_offset, custom_sections[i].payload_offset);
EXPECT_EQ(expected[i].payload_length, custom_sections[i].payload_length);
EXPECT_EQ(expected[i].section_length, custom_sections[i].section_length);
}
}
};
TEST_F(WasmModuleCustomSectionTest, ThreeUnknownSections) {
static const byte data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
SECTION(Unknown, 4), 1, 'X', 17, 18, // --
SECTION(Unknown, 9), 3, 'f', 'o', 'o', 5, 6, 7, 8, 9, // --
SECTION(Unknown, 8), 5, 'o', 't', 'h', 'e', 'r', 7, 8, // --
};
static CustomSectionOffset expected[] = {
// sec_start, nm_offset, nm_length, py_offset, py_length, sec_length
{10, 11, 1, 12, 2, 4}, // --
{16, 17, 3, 20, 5, 9}, // --
{27, 28, 5, 33, 2, 8}, // --
};
CheckSections(data, data + sizeof(data), expected, arraysize(expected));
}
TEST_F(WasmModuleCustomSectionTest, TwoKnownTwoUnknownSections) {
static const byte data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
SIGNATURES_SECTION(2, SIG_ENTRY_v_v, SIG_ENTRY_v_v), // --
SECTION(Unknown, 4),
1,
'X',
17,
18, // --
ONE_EMPTY_FUNCTION,
SECTION(Unknown, 8),
5,
'o',
't',
'h',
'e',
'r',
7,
8, // --
};
static CustomSectionOffset expected[] = {
// sec_start, nm_offset, nm_length, py_offset, py_length, sec_length
{19, 20, 1, 21, 2, 4}, // --
{29, 30, 5, 35, 2, 8}, // --
};
CheckSections(data, data + sizeof(data), expected, arraysize(expected));
}
} // namespace wasm
} // namespace internal
} // namespace v8