Line data Source code
1 : // Copyright 2015 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "test/unittests/test-utils.h"
6 :
7 : #include "src/handles.h"
8 : #include "src/objects-inl.h"
9 : #include "src/wasm/module-decoder.h"
10 : #include "src/wasm/wasm-features.h"
11 : #include "src/wasm/wasm-limits.h"
12 : #include "src/wasm/wasm-opcodes.h"
13 : #include "test/common/wasm/flag-utils.h"
14 : #include "test/common/wasm/wasm-macro-gen.h"
15 : #include "testing/gmock-support.h"
16 :
17 : using testing::HasSubstr;
18 :
19 : namespace v8 {
20 : namespace internal {
21 : namespace wasm {
22 : namespace module_decoder_unittest {
23 :
24 : #define WASM_INIT_EXPR_I32V_1(val) WASM_I32V_1(val), kExprEnd
25 : #define WASM_INIT_EXPR_I32V_2(val) WASM_I32V_2(val), kExprEnd
26 : #define WASM_INIT_EXPR_I32V_3(val) WASM_I32V_3(val), kExprEnd
27 : #define WASM_INIT_EXPR_I32V_4(val) WASM_I32V_4(val), kExprEnd
28 : #define WASM_INIT_EXPR_I32V_5(val) WASM_I32V_5(val), kExprEnd
29 : #define WASM_INIT_EXPR_F32(val) WASM_F32(val), kExprEnd
30 : #define WASM_INIT_EXPR_I64(val) WASM_I64(val), kExprEnd
31 : #define WASM_INIT_EXPR_F64(val) WASM_F64(val), kExprEnd
32 : #define WASM_INIT_EXPR_ANYREF WASM_REF_NULL, kExprEnd
33 : #define WASM_INIT_EXPR_GLOBAL(index) WASM_GET_GLOBAL(index), kExprEnd
34 :
35 : #define REF_NULL_ELEMENT kExprRefNull, kExprEnd
36 : #define REF_FUNC_ELEMENT(v) kExprRefFunc, U32V_1(v), kExprEnd
37 :
38 : #define EMPTY_BODY 0
39 : #define NOP_BODY 2, 0, kExprNop
40 :
41 : #define SIG_ENTRY_i_i SIG_ENTRY_x_x(kLocalI32, kLocalI32)
42 :
43 : #define UNKNOWN_SECTION(size) 0, U32V_1(size + 5), ADD_COUNT('l', 'u', 'l', 'z')
44 :
45 : template <typename... Args>
46 : std::integral_constant<size_t, sizeof...(Args)> CountArgsHelper(Args...);
47 : #define COUNT_ARGS(...) (decltype(CountArgsHelper(__VA_ARGS__))::value)
48 :
49 : template <size_t num>
50 : struct CheckLEB1 : std::integral_constant<size_t, num> {
51 : static_assert(num <= I32V_MAX(1), "LEB range check");
52 : };
53 : #define CHECK_LEB1(num) CheckLEB1<num>::value
54 :
55 : #define ADD_COUNT(...) CHECK_LEB1(COUNT_ARGS(__VA_ARGS__)), __VA_ARGS__
56 :
57 : #define SECTION(name, ...) k##name##SectionCode, ADD_COUNT(__VA_ARGS__)
58 :
59 : #define SIGNATURES_SECTION(count, ...) SECTION(Type, U32V_1(count), __VA_ARGS__)
60 : #define FUNCTION_SIGNATURES_SECTION(count, ...) \
61 : SECTION(Function, U32V_1(count), __VA_ARGS__)
62 :
63 : #define FOO_STRING ADD_COUNT('f', 'o', 'o')
64 : #define NO_LOCAL_NAMES 0
65 :
66 : #define EMPTY_SIGNATURES_SECTION SECTION(Type, ENTRY_COUNT(0))
67 : #define EMPTY_FUNCTION_SIGNATURES_SECTION SECTION(Function, ENTRY_COUNT(0))
68 : #define EMPTY_FUNCTION_BODIES_SECTION SECTION(Code, ENTRY_COUNT(0))
69 : #define SECTION_NAMES(...) \
70 : SECTION(Unknown, ADD_COUNT('n', 'a', 'm', 'e'), ##__VA_ARGS__)
71 : #define EMPTY_NAMES_SECTION SECTION_NAMES()
72 : #define SECTION_SRC_MAP(...) \
73 : SECTION(Unknown, \
74 : ADD_COUNT('s', 'o', 'u', 'r', 'c', 'e', 'M', 'a', 'p', 'p', 'i', \
75 : 'n', 'g', 'U', 'R', 'L'), \
76 : ADD_COUNT(__VA_ARGS__))
77 : #define SECTION_COMPILATION_HINTS(...) \
78 : SECTION(Unknown, \
79 : ADD_COUNT('c', 'o', 'm', 'p', 'i', 'l', 'a', 't', 'i', 'o', 'n', \
80 : 'H', 'i', 'n', 't', 's'), \
81 : ADD_COUNT(__VA_ARGS__))
82 :
83 : #define FAIL_IF_NO_EXPERIMENTAL_EH(data) \
84 : do { \
85 : ModuleResult result = DecodeModule((data), (data) + sizeof((data))); \
86 : EXPECT_FALSE(result.ok()); \
87 : } while (false)
88 :
89 : #define X1(...) __VA_ARGS__
90 : #define X2(...) __VA_ARGS__, __VA_ARGS__
91 : #define X3(...) __VA_ARGS__, __VA_ARGS__, __VA_ARGS__
92 : #define X4(...) __VA_ARGS__, __VA_ARGS__, __VA_ARGS__, __VA_ARGS__
93 :
94 : #define ONE_EMPTY_FUNCTION(sig_index) \
95 : SECTION(Function, ENTRY_COUNT(1), X1(sig_index))
96 :
97 : #define TWO_EMPTY_FUNCTIONS(sig_index) \
98 : SECTION(Function, ENTRY_COUNT(2), X2(sig_index))
99 :
100 : #define THREE_EMPTY_FUNCTIONS(sig_index) \
101 : SECTION(Function, ENTRY_COUNT(3), X3(sig_index))
102 :
103 : #define FOUR_EMPTY_FUNCTIONS(sig_index) \
104 : SECTION(Function, ENTRY_COUNT(4), X4(sig_index))
105 :
106 : #define ONE_EMPTY_BODY SECTION(Code, ENTRY_COUNT(1), X1(EMPTY_BODY))
107 : #define TWO_EMPTY_BODIES SECTION(Code, ENTRY_COUNT(2), X2(EMPTY_BODY))
108 : #define THREE_EMPTY_BODIES SECTION(Code, ENTRY_COUNT(3), X3(EMPTY_BODY))
109 : #define FOUR_EMPTY_BODIES SECTION(Code, ENTRY_COUNT(4), X4(EMPTY_BODY))
110 :
111 : #define SIGNATURES_SECTION_VOID_VOID \
112 : SECTION(Type, ENTRY_COUNT(1), SIG_ENTRY_v_v)
113 :
114 : #define LINEAR_MEMORY_INDEX_0 0
115 :
116 : #define EXCEPTION_ENTRY(sig_index) U32V_1(kExceptionAttribute), sig_index
117 :
118 : #define EXPECT_VERIFIES(data) \
119 : do { \
120 : ModuleResult result = DecodeModule(data, data + sizeof(data)); \
121 : EXPECT_TRUE(result.ok()); \
122 : } while (false)
123 :
124 : #define EXPECT_FAILURE_LEN(data, length) \
125 : do { \
126 : ModuleResult result = DecodeModule(data, data + length); \
127 : EXPECT_FALSE(result.ok()); \
128 : } while (false)
129 :
130 : #define EXPECT_FAILURE(data) EXPECT_FAILURE_LEN(data, sizeof(data))
131 :
132 : #define EXPECT_OFF_END_FAILURE(data, min) \
133 : do { \
134 : STATIC_ASSERT(min < arraysize(data)); \
135 : for (size_t length = min; length < arraysize(data); length++) { \
136 : EXPECT_FAILURE_LEN(data, length); \
137 : } \
138 : } while (false)
139 :
140 : #define EXPECT_OK(result) \
141 : do { \
142 : EXPECT_TRUE(result.ok()); \
143 : if (!result.ok()) return; \
144 : } while (false)
145 :
146 : #define EXPECT_NOT_OK(result, msg) \
147 : do { \
148 : EXPECT_FALSE(result.ok()); \
149 : EXPECT_THAT(result.error().message(), HasSubstr(msg)); \
150 : } while (false)
151 :
152 : static size_t SizeOfVarInt(size_t value) {
153 : size_t size = 0;
154 : do {
155 13 : size++;
156 13 : value = value >> 7;
157 13 : } while (value > 0);
158 : return size;
159 : }
160 :
161 : struct ValueTypePair {
162 : uint8_t code;
163 : ValueType type;
164 : } kValueTypes[] = {
165 : {kLocalI32, kWasmI32}, // --
166 : {kLocalI64, kWasmI64}, // --
167 : {kLocalF32, kWasmF32}, // --
168 : {kLocalF64, kWasmF64}, // --
169 : {kLocalAnyFunc, kWasmAnyFunc}, // --
170 : {kLocalAnyRef, kWasmAnyRef} // --
171 : };
172 :
173 345 : class WasmModuleVerifyTest : public TestWithIsolateAndZone {
174 : public:
175 : WasmFeatures enabled_features_;
176 :
177 237 : ModuleResult DecodeModule(const byte* module_start, const byte* module_end) {
178 : // Add the wasm magic and version number automatically.
179 237 : size_t size = static_cast<size_t>(module_end - module_start);
180 237 : byte header[] = {WASM_MODULE_HEADER};
181 237 : size_t total = sizeof(header) + size;
182 237 : auto temp = new byte[total];
183 : memcpy(temp, header, sizeof(header));
184 237 : if (size > 0) {
185 236 : memcpy(temp + sizeof(header), module_start, size);
186 : }
187 474 : ModuleResult result = DecodeWasmModule(
188 : enabled_features_, temp, temp + total, false, kWasmOrigin,
189 237 : isolate()->counters(), isolate()->wasm_engine()->allocator());
190 237 : delete[] temp;
191 237 : return result;
192 : }
193 64 : ModuleResult DecodeModuleNoHeader(const byte* module_start,
194 : const byte* module_end) {
195 128 : return DecodeWasmModule(enabled_features_, module_start, module_end, false,
196 : kWasmOrigin, isolate()->counters(),
197 64 : isolate()->wasm_engine()->allocator());
198 : }
199 : };
200 :
201 : namespace {
202 : class EnableBoolScope {
203 : public:
204 : bool prev_;
205 : bool* ptr_;
206 : explicit EnableBoolScope(bool* ptr, bool val = true)
207 51 : : prev_(*ptr), ptr_(ptr) {
208 51 : *ptr = val;
209 : }
210 43 : ~EnableBoolScope() { *ptr_ = prev_; }
211 : };
212 :
213 : #define WASM_FEATURE_SCOPE(feat) \
214 : EnableBoolScope feat##_scope(&this->enabled_features_.feat)
215 :
216 : #define WASM_FEATURE_SCOPE_VAL(feat, val) \
217 : EnableBoolScope feat##_scope(&this->enabled_features_.feat, val)
218 : } // namespace
219 :
220 15445 : TEST_F(WasmModuleVerifyTest, WrongMagic) {
221 65 : for (uint32_t x = 1; x; x <<= 1) {
222 32 : const byte data[] = {U32_LE(kWasmMagic ^ x), U32_LE(kWasmVersion)};
223 96 : ModuleResult result = DecodeModuleNoHeader(data, data + sizeof(data));
224 64 : EXPECT_FALSE(result.ok());
225 : }
226 1 : }
227 :
228 15445 : TEST_F(WasmModuleVerifyTest, WrongVersion) {
229 65 : for (uint32_t x = 1; x; x <<= 1) {
230 32 : const byte data[] = {U32_LE(kWasmMagic), U32_LE(kWasmVersion ^ x)};
231 96 : ModuleResult result = DecodeModuleNoHeader(data, data + sizeof(data));
232 64 : EXPECT_FALSE(result.ok());
233 : }
234 1 : }
235 :
236 15445 : TEST_F(WasmModuleVerifyTest, DecodeEmpty) {
237 3 : ModuleResult result = DecodeModule(nullptr, nullptr);
238 1 : EXPECT_TRUE(result.ok());
239 1 : }
240 :
241 15445 : TEST_F(WasmModuleVerifyTest, OneGlobal) {
242 : static const byte data[] = {
243 : SECTION(Global, // --
244 : ENTRY_COUNT(1), // --
245 : kLocalI32, // local type
246 : 0, // immutable
247 : WASM_INIT_EXPR_I32V_1(13)) // init
248 1 : };
249 :
250 : {
251 : // Should decode to exactly one global.
252 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
253 2 : EXPECT_OK(result);
254 2 : EXPECT_EQ(1u, result.value()->globals.size());
255 2 : EXPECT_EQ(0u, result.value()->functions.size());
256 2 : EXPECT_EQ(0u, result.value()->data_segments.size());
257 :
258 : const WasmGlobal* global = &result.value()->globals.back();
259 :
260 2 : EXPECT_EQ(kWasmI32, global->type);
261 2 : EXPECT_EQ(0u, global->offset);
262 2 : EXPECT_FALSE(global->mutability);
263 2 : EXPECT_EQ(WasmInitExpr::kI32Const, global->init.kind);
264 2 : EXPECT_EQ(13, global->init.val.i32_const);
265 : }
266 :
267 29 : EXPECT_OFF_END_FAILURE(data, 1);
268 : }
269 :
270 15445 : TEST_F(WasmModuleVerifyTest, AnyRefGlobal) {
271 1 : WASM_FEATURE_SCOPE(anyref);
272 : static const byte data[] = {
273 : SECTION(Global, // --
274 : ENTRY_COUNT(1), // --
275 : kLocalAnyRef, // local type
276 : 0, // immutable
277 : WASM_INIT_EXPR_ANYREF) // init
278 : };
279 :
280 : {
281 : // Should decode to exactly one global.
282 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
283 2 : EXPECT_OK(result);
284 2 : EXPECT_EQ(1u, result.value()->globals.size());
285 2 : EXPECT_EQ(0u, result.value()->functions.size());
286 2 : EXPECT_EQ(0u, result.value()->data_segments.size());
287 :
288 : const WasmGlobal* global = &result.value()->globals.back();
289 :
290 2 : EXPECT_EQ(kWasmAnyRef, global->type);
291 2 : EXPECT_FALSE(global->mutability);
292 2 : EXPECT_EQ(WasmInitExpr::kRefNullConst, global->init.kind);
293 : }
294 : }
295 :
296 15445 : TEST_F(WasmModuleVerifyTest, AnyRefGlobalWithGlobalInit) {
297 1 : WASM_FEATURE_SCOPE(anyref);
298 : static const byte data[] = {
299 : SECTION(Import, // --
300 : ENTRY_COUNT(1), // number of imports
301 : ADD_COUNT('m'), // module name
302 : ADD_COUNT('f'), // global name
303 : kExternalGlobal, // import kind
304 : kLocalAnyRef, // type
305 : 0), // mutability
306 : SECTION(Global, // --
307 : ENTRY_COUNT(1),
308 : kLocalAnyRef, // local type
309 : 0, // immutable
310 : WASM_INIT_EXPR_GLOBAL(0)),
311 : };
312 :
313 : {
314 : // Should decode to exactly one global.
315 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
316 2 : EXPECT_OK(result);
317 2 : EXPECT_EQ(2u, result.value()->globals.size());
318 2 : EXPECT_EQ(0u, result.value()->functions.size());
319 2 : EXPECT_EQ(0u, result.value()->data_segments.size());
320 :
321 : const WasmGlobal* global = &result.value()->globals.back();
322 :
323 2 : EXPECT_EQ(kWasmAnyRef, global->type);
324 2 : EXPECT_FALSE(global->mutability);
325 2 : EXPECT_EQ(WasmInitExpr::kGlobalIndex, global->init.kind);
326 : }
327 : }
328 :
329 15445 : TEST_F(WasmModuleVerifyTest, Global_invalid_type) {
330 : static const byte data[] = {
331 : SECTION(Global, // --
332 : ENTRY_COUNT(1), // --
333 : 64, // invalid memory type
334 : 1, // mutable
335 : WASM_INIT_EXPR_I32V_1(33)), // init
336 1 : };
337 :
338 4 : EXPECT_FAILURE(data);
339 1 : }
340 :
341 15445 : TEST_F(WasmModuleVerifyTest, Global_invalid_type2) {
342 : static const byte data[] = {
343 : SECTION(Global, // --
344 : ENTRY_COUNT(1), // --
345 : kLocalVoid, // invalid memory type
346 : 1, // mutable
347 : WASM_INIT_EXPR_I32V_1(33)), // init
348 1 : };
349 :
350 4 : EXPECT_FAILURE(data);
351 1 : }
352 :
353 15445 : TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
354 : static const byte data[] = {SECTION(Global, ENTRY_COUNT(0))};
355 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
356 2 : EXPECT_OK(result);
357 : }
358 :
359 15445 : TEST_F(WasmModuleVerifyTest, ExportMutableGlobal) {
360 : {
361 : static const byte data[] = {
362 : SECTION(Global, // --
363 : ENTRY_COUNT(1), // --
364 : kLocalI32, // local type
365 : 0, // immutable
366 : WASM_INIT_EXPR_I32V_1(13)), // init
367 : SECTION(Export, // --
368 : ENTRY_COUNT(1), // export count
369 : ADD_COUNT('n', 'a', 'm', 'e'), // name
370 : kExternalGlobal, // global
371 : 0), // global index
372 1 : };
373 4 : EXPECT_VERIFIES(data);
374 : }
375 : {
376 : static const byte data[] = {
377 : SECTION(Global, // --
378 : ENTRY_COUNT(1), // --
379 : kLocalI32, // local type
380 : 1, // mutable
381 : WASM_INIT_EXPR_I32V_1(13)), // init
382 : SECTION(Export, // --
383 : ENTRY_COUNT(1), // export count
384 : ADD_COUNT('n', 'a', 'm', 'e'), // name
385 : kExternalGlobal, // global
386 : 0), // global index
387 1 : };
388 4 : EXPECT_VERIFIES(data);
389 : }
390 1 : }
391 :
392 7 : static void AppendUint32v(std::vector<byte>& buffer, uint32_t val) {
393 6 : while (true) {
394 13 : uint32_t next = val >> 7;
395 13 : uint32_t out = val & 0x7F;
396 13 : if (next) {
397 12 : buffer.push_back(static_cast<byte>(0x80 | out));
398 : val = next;
399 : } else {
400 14 : buffer.push_back(static_cast<byte>(out));
401 : break;
402 : }
403 : }
404 7 : }
405 :
406 15445 : TEST_F(WasmModuleVerifyTest, NGlobals) {
407 : static const byte data[] = {
408 : kLocalF32, // memory type
409 : 0, // immutable
410 : WASM_INIT_EXPR_F32(7.7), // init
411 1 : };
412 :
413 15 : for (uint32_t i = 0; i < kV8MaxWasmGlobals; i = i * 13 + 1) {
414 : std::vector<byte> buffer;
415 14 : size_t size = SizeOfVarInt(i) + i * sizeof(data);
416 7 : const byte globals[] = {kGlobalSectionCode, U32V_5(size)};
417 91 : for (size_t g = 0; g != sizeof(globals); ++g) {
418 42 : buffer.push_back(globals[g]);
419 : }
420 7 : AppendUint32v(buffer, i); // Number of globals.
421 871513 : for (uint32_t j = 0; j < i; j++) {
422 : buffer.insert(buffer.end(), data, data + sizeof(data));
423 : }
424 :
425 21 : ModuleResult result = DecodeModule(&buffer[0], &buffer[0] + buffer.size());
426 14 : EXPECT_OK(result);
427 : }
428 : }
429 :
430 15445 : TEST_F(WasmModuleVerifyTest, GlobalWithInvalidMemoryType) {
431 : static const byte data[] = {SECTION(Global, // --
432 : ENTRY_COUNT(1), // --
433 : 33, // memory type
434 : 0, // exported
435 1 : WASM_INIT_EXPR_I32V_1(1))};
436 :
437 4 : EXPECT_FAILURE(data);
438 1 : }
439 :
440 15445 : TEST_F(WasmModuleVerifyTest, TwoGlobals) {
441 : static const byte data[] = {SECTION(Global, // --
442 : ENTRY_COUNT(2), // --
443 : kLocalF32, // type
444 : 0, // immutable
445 : WASM_INIT_EXPR_F32(22.0), // --
446 : kLocalF64, // type
447 : 1, // mutable
448 1 : WASM_INIT_EXPR_F64(23.0))}; // --
449 :
450 : {
451 : // Should decode to exactly two globals.
452 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
453 2 : EXPECT_OK(result);
454 2 : EXPECT_EQ(2u, result.value()->globals.size());
455 2 : EXPECT_EQ(0u, result.value()->functions.size());
456 2 : EXPECT_EQ(0u, result.value()->data_segments.size());
457 :
458 : const WasmGlobal* g0 = &result.value()->globals[0];
459 :
460 2 : EXPECT_EQ(kWasmF32, g0->type);
461 2 : EXPECT_EQ(0u, g0->offset);
462 2 : EXPECT_FALSE(g0->mutability);
463 2 : EXPECT_EQ(WasmInitExpr::kF32Const, g0->init.kind);
464 :
465 : const WasmGlobal* g1 = &result.value()->globals[1];
466 :
467 2 : EXPECT_EQ(kWasmF64, g1->type);
468 2 : EXPECT_EQ(8u, g1->offset);
469 1 : EXPECT_TRUE(g1->mutability);
470 2 : EXPECT_EQ(WasmInitExpr::kF64Const, g1->init.kind);
471 : }
472 :
473 89 : EXPECT_OFF_END_FAILURE(data, 1);
474 : }
475 :
476 15445 : TEST_F(WasmModuleVerifyTest, ZeroExceptions) {
477 : static const byte data[] = {SECTION(Exception, ENTRY_COUNT(0))};
478 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
479 :
480 1 : WASM_FEATURE_SCOPE(eh);
481 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
482 2 : EXPECT_OK(result);
483 2 : EXPECT_EQ(0u, result.value()->exceptions.size());
484 : }
485 :
486 15445 : TEST_F(WasmModuleVerifyTest, OneI32Exception) {
487 : static const byte data[] = {
488 : SECTION(Type, ENTRY_COUNT(1), SIG_ENTRY_v_x(kLocalI32)), // sig#0 (i32)
489 : SECTION(Exception, ENTRY_COUNT(1),
490 : EXCEPTION_ENTRY(SIG_INDEX(0)))}; // except[0] (sig#0)
491 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
492 :
493 1 : WASM_FEATURE_SCOPE(eh);
494 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
495 2 : EXPECT_OK(result);
496 2 : EXPECT_EQ(1u, result.value()->exceptions.size());
497 :
498 : const WasmException& e0 = result.value()->exceptions.front();
499 2 : EXPECT_EQ(1u, e0.sig->parameter_count());
500 3 : EXPECT_EQ(kWasmI32, e0.sig->GetParam(0));
501 : }
502 :
503 15445 : TEST_F(WasmModuleVerifyTest, TwoExceptions) {
504 : static const byte data[] = {
505 : SECTION(Type, ENTRY_COUNT(2),
506 : SIG_ENTRY_v_x(kLocalI32), // sig#0 (i32)
507 : SIG_ENTRY_v_xx(kLocalF32, kLocalI64)), // sig#1 (f32, i64)
508 : SECTION(Exception, ENTRY_COUNT(2),
509 : EXCEPTION_ENTRY(SIG_INDEX(1)), // except[0] (sig#1)
510 : EXCEPTION_ENTRY(SIG_INDEX(0)))}; // except[1] (sig#0)
511 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
512 :
513 1 : WASM_FEATURE_SCOPE(eh);
514 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
515 2 : EXPECT_OK(result);
516 2 : EXPECT_EQ(2u, result.value()->exceptions.size());
517 : const WasmException& e0 = result.value()->exceptions.front();
518 2 : EXPECT_EQ(2u, e0.sig->parameter_count());
519 3 : EXPECT_EQ(kWasmF32, e0.sig->GetParam(0));
520 3 : EXPECT_EQ(kWasmI64, e0.sig->GetParam(1));
521 : const WasmException& e1 = result.value()->exceptions.back();
522 3 : EXPECT_EQ(kWasmI32, e1.sig->GetParam(0));
523 : }
524 :
525 15445 : TEST_F(WasmModuleVerifyTest, Exception_invalid_sig_index) {
526 : static const byte data[] = {
527 : SIGNATURES_SECTION_VOID_VOID,
528 : SECTION(Exception, ENTRY_COUNT(1),
529 : EXCEPTION_ENTRY(
530 : SIG_INDEX(23)))}; // except[0] (sig#23 [out-of-bounds])
531 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
532 :
533 : // Should fail decoding exception section.
534 1 : WASM_FEATURE_SCOPE(eh);
535 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
536 6 : EXPECT_NOT_OK(result, "signature index 23 out of bounds");
537 1 : }
538 :
539 15445 : TEST_F(WasmModuleVerifyTest, Exception_invalid_sig_return) {
540 : static const byte data[] = {
541 : SECTION(Type, ENTRY_COUNT(1), SIG_ENTRY_i_i),
542 : SECTION(Exception, ENTRY_COUNT(1),
543 : EXCEPTION_ENTRY(
544 : SIG_INDEX(0)))}; // except[0] (sig#0 [invalid-return-type])
545 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
546 :
547 : // Should fail decoding exception section.
548 1 : WASM_FEATURE_SCOPE(eh);
549 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
550 6 : EXPECT_NOT_OK(result, "exception signature 0 has non-void return");
551 1 : }
552 :
553 15445 : TEST_F(WasmModuleVerifyTest, Exception_invalid_attribute) {
554 : static const byte data[] = {
555 : SECTION(Type, ENTRY_COUNT(1), SIG_ENTRY_i_i),
556 : SECTION(Exception, ENTRY_COUNT(1), 23,
557 : SIG_INDEX(0))}; // except[0] (sig#0) [invalid-attribute]
558 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
559 :
560 : // Should fail decoding exception section.
561 1 : WASM_FEATURE_SCOPE(eh);
562 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
563 6 : EXPECT_NOT_OK(result, "exception attribute 23 not supported");
564 1 : }
565 :
566 15445 : TEST_F(WasmModuleVerifyTest, ExceptionSectionCorrectPlacement) {
567 : static const byte data[] = {SECTION(Import, ENTRY_COUNT(0)),
568 : SECTION(Exception, ENTRY_COUNT(0)),
569 : SECTION(Export, ENTRY_COUNT(0))};
570 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
571 :
572 1 : WASM_FEATURE_SCOPE(eh);
573 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
574 2 : EXPECT_OK(result);
575 : }
576 :
577 15445 : TEST_F(WasmModuleVerifyTest, ExceptionSectionAfterExport) {
578 : static const byte data[] = {SECTION(Export, ENTRY_COUNT(0)),
579 : SECTION(Exception, ENTRY_COUNT(0))};
580 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
581 :
582 1 : WASM_FEATURE_SCOPE(eh);
583 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
584 6 : EXPECT_NOT_OK(result,
585 : "The Exception section must appear before the Export section");
586 1 : }
587 :
588 15445 : TEST_F(WasmModuleVerifyTest, ExceptionSectionBeforeGlobal) {
589 : static const byte data[] = {SECTION(Exception, ENTRY_COUNT(0)),
590 : SECTION(Global, ENTRY_COUNT(0))};
591 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
592 :
593 1 : WASM_FEATURE_SCOPE(eh);
594 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
595 6 : EXPECT_NOT_OK(result, "unexpected section <Global>");
596 1 : }
597 :
598 15445 : TEST_F(WasmModuleVerifyTest, ExceptionSectionAfterMemoryBeforeGlobal) {
599 : STATIC_ASSERT(kMemorySectionCode + 1 == kGlobalSectionCode);
600 : static const byte data[] = {SECTION(Memory, ENTRY_COUNT(0)),
601 : SECTION(Exception, ENTRY_COUNT(0)),
602 : SECTION(Global, ENTRY_COUNT(0))};
603 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
604 :
605 1 : WASM_FEATURE_SCOPE(eh);
606 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
607 6 : EXPECT_NOT_OK(result, "unexpected section <Global>");
608 1 : }
609 :
610 15445 : TEST_F(WasmModuleVerifyTest, ExceptionImport) {
611 : static const byte data[] = {
612 : SIGNATURES_SECTION_VOID_VOID,
613 : SECTION(Import, // section header
614 : ENTRY_COUNT(1), // number of imports
615 : ADD_COUNT('m'), // module name
616 : ADD_COUNT('e', 'x'), // exception name
617 : kExternalException, // import kind
618 : EXCEPTION_ENTRY(SIG_INDEX(0)))}; // except[0] (sig#0)
619 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
620 :
621 1 : WASM_FEATURE_SCOPE(eh);
622 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
623 2 : EXPECT_OK(result);
624 2 : EXPECT_EQ(1u, result.value()->exceptions.size());
625 2 : EXPECT_EQ(1u, result.value()->import_table.size());
626 : }
627 :
628 15445 : TEST_F(WasmModuleVerifyTest, ExceptionExport) {
629 : static const byte data[] = {
630 : SIGNATURES_SECTION_VOID_VOID,
631 : SECTION(Exception, ENTRY_COUNT(1),
632 : EXCEPTION_ENTRY(SIG_INDEX(0))), // except[0] (sig#0)
633 : SECTION(Export, ENTRY_COUNT(1), // --
634 : NO_NAME, // --
635 : kExternalException, // --
636 : EXCEPTION_INDEX(0))};
637 4 : FAIL_IF_NO_EXPERIMENTAL_EH(data);
638 :
639 1 : WASM_FEATURE_SCOPE(eh);
640 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
641 2 : EXPECT_OK(result);
642 2 : EXPECT_EQ(1u, result.value()->exceptions.size());
643 2 : EXPECT_EQ(1u, result.value()->export_table.size());
644 : }
645 :
646 15445 : TEST_F(WasmModuleVerifyTest, OneSignature) {
647 : {
648 : static const byte data[] = {SIGNATURES_SECTION_VOID_VOID};
649 4 : EXPECT_VERIFIES(data);
650 : }
651 :
652 : {
653 : static const byte data[] = {SECTION(Type, ENTRY_COUNT(1), SIG_ENTRY_i_i)};
654 4 : EXPECT_VERIFIES(data);
655 : }
656 1 : }
657 :
658 15445 : TEST_F(WasmModuleVerifyTest, MultipleSignatures) {
659 : static const byte data[] = {
660 : SECTION(
661 : Type, // --
662 : ENTRY_COUNT(3), // --
663 : SIG_ENTRY_v_v, // void -> void
664 : SIG_ENTRY_x_x(kLocalI32, kLocalF32), // f32 -> i32
665 : SIG_ENTRY_x_xx(kLocalI32, kLocalF64, kLocalF64)), // f64,f64 -> i32
666 : };
667 :
668 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
669 2 : EXPECT_OK(result);
670 2 : EXPECT_EQ(3u, result.value()->signatures.size());
671 1 : if (result.value()->signatures.size() == 3) {
672 2 : EXPECT_EQ(0u, result.value()->signatures[0]->return_count());
673 2 : EXPECT_EQ(1u, result.value()->signatures[1]->return_count());
674 2 : EXPECT_EQ(1u, result.value()->signatures[2]->return_count());
675 :
676 2 : EXPECT_EQ(0u, result.value()->signatures[0]->parameter_count());
677 2 : EXPECT_EQ(1u, result.value()->signatures[1]->parameter_count());
678 2 : EXPECT_EQ(2u, result.value()->signatures[2]->parameter_count());
679 : }
680 :
681 65 : EXPECT_OFF_END_FAILURE(data, 1);
682 : }
683 :
684 15445 : TEST_F(WasmModuleVerifyTest, DataSegmentWithImmutableImportedGlobal) {
685 : // Import 2 globals so that we can initialize data with a global index != 0.
686 : const byte data[] = {
687 : SECTION(Import, // section header
688 : ENTRY_COUNT(2), // number of imports
689 : ADD_COUNT('m'), // module name
690 : ADD_COUNT('f'), // global name
691 : kExternalGlobal, // import kind
692 : kLocalI32, // type
693 : 0, // mutability
694 : ADD_COUNT('n'), // module name
695 : ADD_COUNT('g'), // global name
696 : kExternalGlobal, // import kind
697 : kLocalI32, // type
698 : 0), // mutability
699 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 28, 28),
700 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0,
701 : WASM_INIT_EXPR_GLOBAL(1), // dest addr
702 : U32V_1(3), // source size
703 : 'a', 'b', 'c') // data bytes
704 1 : };
705 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
706 2 : EXPECT_OK(result);
707 1 : WasmInitExpr expr = result.value()->data_segments.back().dest_addr;
708 2 : EXPECT_EQ(WasmInitExpr::kGlobalIndex, expr.kind);
709 2 : EXPECT_EQ(1u, expr.val.global_index);
710 : }
711 :
712 15445 : TEST_F(WasmModuleVerifyTest, DataSegmentWithMutableImportedGlobal) {
713 : // Only an immutable imported global can be used as an init_expr.
714 : const byte data[] = {
715 : SECTION(Import, // section header
716 : ENTRY_COUNT(1), // number of imports
717 : ADD_COUNT('m'), // module name
718 : ADD_COUNT('f'), // global name
719 : kExternalGlobal, // import kind
720 : kLocalI32, // type
721 : 1), // mutability
722 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 28, 28),
723 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0,
724 : WASM_INIT_EXPR_GLOBAL(0), // dest addr
725 : U32V_1(3), // source size
726 : 'a', 'b', 'c') // data bytes
727 1 : };
728 4 : EXPECT_FAILURE(data);
729 1 : }
730 15445 : TEST_F(WasmModuleVerifyTest, DataSegmentWithImmutableGlobal) {
731 : // Only an immutable imported global can be used as an init_expr.
732 : const byte data[] = {
733 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 28, 28),
734 : SECTION(Global, ENTRY_COUNT(1),
735 : kLocalI32, // local type
736 : 0, // immutable
737 : WASM_INIT_EXPR_I32V_3(0x9BBAA)), // init
738 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0,
739 : WASM_INIT_EXPR_GLOBAL(0), // dest addr
740 : U32V_1(3), // source size
741 : 'a', 'b', 'c') // data bytes
742 1 : };
743 4 : EXPECT_FAILURE(data);
744 1 : }
745 :
746 15445 : TEST_F(WasmModuleVerifyTest, OneDataSegment) {
747 1 : const byte kDataSegmentSourceOffset = 24;
748 : const byte data[] = {
749 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 28, 28),
750 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0,
751 : WASM_INIT_EXPR_I32V_3(0x9BBAA), // dest addr
752 : U32V_1(3), // source size
753 : 'a', 'b', 'c') // data bytes
754 1 : };
755 :
756 : {
757 4 : EXPECT_VERIFIES(data);
758 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
759 2 : EXPECT_OK(result);
760 2 : EXPECT_EQ(0u, result.value()->globals.size());
761 2 : EXPECT_EQ(0u, result.value()->functions.size());
762 2 : EXPECT_EQ(1u, result.value()->data_segments.size());
763 :
764 : const WasmDataSegment* segment = &result.value()->data_segments.back();
765 :
766 2 : EXPECT_EQ(WasmInitExpr::kI32Const, segment->dest_addr.kind);
767 2 : EXPECT_EQ(0x9BBAA, segment->dest_addr.val.i32_const);
768 2 : EXPECT_EQ(kDataSegmentSourceOffset, segment->source.offset());
769 2 : EXPECT_EQ(3u, segment->source.length());
770 : }
771 :
772 21 : EXPECT_OFF_END_FAILURE(data, 14);
773 : }
774 :
775 15445 : TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
776 1 : const byte kDataSegment0SourceOffset = 24;
777 1 : const byte kDataSegment1SourceOffset = kDataSegment0SourceOffset + 11;
778 :
779 : const byte data[] = {
780 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 28, 28),
781 : SECTION(Data,
782 : ENTRY_COUNT(2), // segment count
783 : LINEAR_MEMORY_INDEX_0,
784 : WASM_INIT_EXPR_I32V_3(0x7FFEE), // #0: dest addr
785 : U32V_1(4), // source size
786 : 1, 2, 3, 4, // data bytes
787 : LINEAR_MEMORY_INDEX_0,
788 : WASM_INIT_EXPR_I32V_3(0x6DDCC), // #1: dest addr
789 : U32V_1(10), // source size
790 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) // data bytes
791 1 : };
792 :
793 : {
794 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
795 2 : EXPECT_OK(result);
796 2 : EXPECT_EQ(0u, result.value()->globals.size());
797 2 : EXPECT_EQ(0u, result.value()->functions.size());
798 2 : EXPECT_EQ(2u, result.value()->data_segments.size());
799 :
800 : const WasmDataSegment* s0 = &result.value()->data_segments[0];
801 : const WasmDataSegment* s1 = &result.value()->data_segments[1];
802 :
803 2 : EXPECT_EQ(WasmInitExpr::kI32Const, s0->dest_addr.kind);
804 2 : EXPECT_EQ(0x7FFEE, s0->dest_addr.val.i32_const);
805 2 : EXPECT_EQ(kDataSegment0SourceOffset, s0->source.offset());
806 2 : EXPECT_EQ(4u, s0->source.length());
807 :
808 2 : EXPECT_EQ(WasmInitExpr::kI32Const, s1->dest_addr.kind);
809 2 : EXPECT_EQ(0x6DDCC, s1->dest_addr.val.i32_const);
810 2 : EXPECT_EQ(kDataSegment1SourceOffset, s1->source.offset());
811 2 : EXPECT_EQ(10u, s1->source.length());
812 : }
813 :
814 93 : EXPECT_OFF_END_FAILURE(data, 14);
815 : }
816 :
817 15445 : TEST_F(WasmModuleVerifyTest, DataWithoutMemory) {
818 : const byte data[] = {
819 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0,
820 : WASM_INIT_EXPR_I32V_3(0x9BBAA), // dest addr
821 : U32V_1(3), // source size
822 : 'a', 'b', 'c') // data bytes
823 1 : };
824 4 : EXPECT_FAILURE(data);
825 1 : }
826 :
827 15445 : TEST_F(WasmModuleVerifyTest, MaxMaximumMemorySize) {
828 : {
829 : const byte data[] = {
830 1 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 0, U32V_3(65536))};
831 4 : EXPECT_VERIFIES(data);
832 : }
833 : {
834 : const byte data[] = {
835 1 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 0, U32V_3(65537))};
836 4 : EXPECT_FAILURE(data);
837 : }
838 1 : }
839 :
840 15445 : TEST_F(WasmModuleVerifyTest, DataSegment_wrong_init_type) {
841 : const byte data[] = {
842 : SECTION(Memory, ENTRY_COUNT(1), kHasMaximumFlag, 28, 28),
843 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0,
844 : WASM_INIT_EXPR_F64(9.9), // dest addr
845 : U32V_1(3), // source size
846 : 'a', 'b', 'c') // data bytes
847 1 : };
848 :
849 4 : EXPECT_FAILURE(data);
850 1 : }
851 :
852 15445 : TEST_F(WasmModuleVerifyTest, DataSegmentEndOverflow) {
853 : const byte data[] = {
854 : SECTION(Memory, // memory section
855 : ENTRY_COUNT(1), kHasMaximumFlag, 28, 28),
856 : SECTION(Data, // data section
857 : ENTRY_COUNT(1), // one entry
858 : LINEAR_MEMORY_INDEX_0, // mem index
859 : WASM_INIT_EXPR_I32V_1(0), // offset
860 : U32V_5(0xFFFFFFFF)) // size
861 1 : };
862 :
863 4 : EXPECT_FAILURE(data);
864 1 : }
865 :
866 15445 : TEST_F(WasmModuleVerifyTest, OneIndirectFunction) {
867 : static const byte data[] = {
868 : // sig#0 ---------------------------------------------------------------
869 : SIGNATURES_SECTION_VOID_VOID,
870 : // funcs ---------------------------------------------------------------
871 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
872 : // table declaration ---------------------------------------------------
873 : SECTION(Table, ENTRY_COUNT(1), kLocalAnyFunc, 0, 1),
874 : // code ----------------------------------------------------------------
875 : ONE_EMPTY_BODY};
876 :
877 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
878 2 : EXPECT_OK(result);
879 1 : if (result.ok()) {
880 2 : EXPECT_EQ(1u, result.value()->signatures.size());
881 2 : EXPECT_EQ(1u, result.value()->functions.size());
882 2 : EXPECT_EQ(1u, result.value()->tables.size());
883 2 : EXPECT_EQ(1u, result.value()->tables[0].initial_size);
884 : }
885 : }
886 :
887 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionWithInternalTable) {
888 : static const byte data[] = {
889 : // table ---------------------------------------------------------------
890 : SECTION(Table, ENTRY_COUNT(1), kLocalAnyFunc, 0, 1),
891 : // elements ------------------------------------------------------------
892 : SECTION(Element, ENTRY_COUNT(0))};
893 :
894 4 : EXPECT_VERIFIES(data);
895 1 : }
896 :
897 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionWithImportedTable) {
898 : static const byte data[] = {
899 : // imports -------------------------------------------------------------
900 : SECTION(Import, ENTRY_COUNT(1),
901 : ADD_COUNT('m'), // module name
902 : ADD_COUNT('t'), // table name
903 : kExternalTable, // import kind
904 : kLocalAnyFunc, // elem_type
905 : 0, // no maximum field
906 : 1), // initial size
907 : // elements ------------------------------------------------------------
908 : SECTION(Element, ENTRY_COUNT(0))};
909 :
910 4 : EXPECT_VERIFIES(data);
911 1 : }
912 :
913 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionWithoutTable) {
914 : // Test that an element section without a table causes a validation error.
915 : static const byte data[] = {
916 : // elements ------------------------------------------------------------
917 : SECTION(Element,
918 : ENTRY_COUNT(1), // entry count
919 : 0, // table index
920 : 0, // offset
921 : 0) // number of elements
922 : };
923 :
924 4 : EXPECT_FAILURE(data);
925 1 : }
926 :
927 15445 : TEST_F(WasmModuleVerifyTest, Regression_735887) {
928 : // Test with an invalid function index in the element section.
929 : static const byte data[] = {
930 : // sig#0 ---------------------------------------------------------------
931 : SIGNATURES_SECTION_VOID_VOID,
932 : // funcs ---------------------------------------------------------------
933 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
934 : // table declaration ---------------------------------------------------
935 : SECTION(Table, ENTRY_COUNT(1), kLocalAnyFunc, 0, 1),
936 : // elements ------------------------------------------------------------
937 : SECTION(Element,
938 : ENTRY_COUNT(1), // entry count
939 : TABLE_INDEX0, WASM_INIT_EXPR_I32V_1(0),
940 : 1, // elements count
941 : 0x9A) // invalid I32V as function index
942 1 : };
943 :
944 4 : EXPECT_FAILURE(data);
945 1 : }
946 :
947 15445 : TEST_F(WasmModuleVerifyTest, OneIndirectFunction_one_entry) {
948 : static const byte data[] = {
949 : // sig#0 ---------------------------------------------------------------
950 : SIGNATURES_SECTION_VOID_VOID,
951 : // funcs ---------------------------------------------------------------
952 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
953 : // table declaration ---------------------------------------------------
954 : SECTION(Table, ENTRY_COUNT(1), kLocalAnyFunc, 0, 1),
955 : // elements ------------------------------------------------------------
956 : SECTION(Element,
957 : ENTRY_COUNT(1), // entry count
958 : TABLE_INDEX0, WASM_INIT_EXPR_I32V_1(0),
959 : 1, // elements count
960 : FUNC_INDEX(0)),
961 : // code ----------------------------------------------------------------
962 1 : ONE_EMPTY_BODY};
963 :
964 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
965 2 : EXPECT_OK(result);
966 2 : EXPECT_EQ(1u, result.value()->signatures.size());
967 2 : EXPECT_EQ(1u, result.value()->functions.size());
968 2 : EXPECT_EQ(1u, result.value()->tables.size());
969 2 : EXPECT_EQ(1u, result.value()->tables[0].initial_size);
970 : }
971 :
972 15445 : TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
973 : static const byte data[] = {
974 : // sig#0 -------------------------------------------------------
975 : SECTION(Type,
976 : ENTRY_COUNT(2), // --
977 : SIG_ENTRY_v_v, // void -> void
978 : SIG_ENTRY_v_x(kLocalI32)), // void -> i32
979 : // funcs ------------------------------------------------------
980 : FOUR_EMPTY_FUNCTIONS(SIG_INDEX(0)),
981 : // table declaration -------------------------------------------
982 : SECTION(Table, ENTRY_COUNT(1), kLocalAnyFunc, 0, 8),
983 : // table elements ----------------------------------------------
984 : SECTION(Element,
985 : ENTRY_COUNT(1), // entry count
986 : TABLE_INDEX0, WASM_INIT_EXPR_I32V_1(0),
987 : ADD_COUNT(FUNC_INDEX(0), FUNC_INDEX(1), FUNC_INDEX(2),
988 : FUNC_INDEX(3), FUNC_INDEX(0), FUNC_INDEX(1),
989 : FUNC_INDEX(2), FUNC_INDEX(3))),
990 1 : FOUR_EMPTY_BODIES};
991 :
992 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
993 2 : EXPECT_OK(result);
994 2 : EXPECT_EQ(2u, result.value()->signatures.size());
995 2 : EXPECT_EQ(4u, result.value()->functions.size());
996 2 : EXPECT_EQ(1u, result.value()->tables.size());
997 2 : EXPECT_EQ(8u, result.value()->tables[0].initial_size);
998 : }
999 :
1000 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionMultipleTables) {
1001 : // Test that if we have multiple tables, in the element section we can target
1002 : // and initialize all tables.
1003 1 : WASM_FEATURE_SCOPE(anyref);
1004 1 : WASM_FEATURE_SCOPE(bulk_memory);
1005 : static const byte data[] = {
1006 : // sig#0 ---------------------------------------------------------------
1007 : SIGNATURES_SECTION_VOID_VOID,
1008 : // funcs ---------------------------------------------------------------
1009 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1010 : // table declaration ---------------------------------------------------
1011 : SECTION(Table, ENTRY_COUNT(2), // section header
1012 : kLocalAnyFunc, 0, 5, // table 0
1013 : kLocalAnyFunc, 0, 9), // table 1
1014 : // elements ------------------------------------------------------------
1015 : SECTION(Element,
1016 : ENTRY_COUNT(2), // entry count
1017 : TABLE_INDEX0, // element for table 0
1018 : WASM_INIT_EXPR_I32V_1(0), // index
1019 : 1, // elements count
1020 : FUNC_INDEX(0), // function
1021 : TABLE_INDEX(1), // element for table 1
1022 : WASM_INIT_EXPR_I32V_1(7), // index
1023 : 2, // elements count
1024 : FUNC_INDEX(0), // entry 0
1025 : FUNC_INDEX(0)), // entry 1
1026 : // code ----------------------------------------------------------------
1027 1 : ONE_EMPTY_BODY};
1028 :
1029 4 : EXPECT_VERIFIES(data);
1030 1 : }
1031 :
1032 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionMixedTables) {
1033 : // Test that if we have multiple tables, both imported and module-defined, in
1034 : // the element section we can target and initialize all tables.
1035 1 : WASM_FEATURE_SCOPE(anyref);
1036 1 : WASM_FEATURE_SCOPE(bulk_memory);
1037 : static const byte data[] = {
1038 : // sig#0 ---------------------------------------------------------------
1039 : SIGNATURES_SECTION_VOID_VOID,
1040 : // imports -------------------------------------------------------------
1041 : SECTION(Import, ENTRY_COUNT(2),
1042 : ADD_COUNT('m'), // module name
1043 : ADD_COUNT('t'), // table name
1044 : kExternalTable, // import kind
1045 : kLocalAnyFunc, // elem_type
1046 : 0, // no maximum field
1047 : 5, // initial size
1048 : ADD_COUNT('m'), // module name
1049 : ADD_COUNT('s'), // table name
1050 : kExternalTable, // import kind
1051 : kLocalAnyFunc, // elem_type
1052 : 0, // no maximum field
1053 : 10), // initial size
1054 : // funcs ---------------------------------------------------------------
1055 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1056 : // table declaration ---------------------------------------------------
1057 : SECTION(Table, ENTRY_COUNT(2), // section header
1058 : kLocalAnyFunc, 0, 15, // table 0
1059 : kLocalAnyFunc, 0, 19), // table 1
1060 : // elements ------------------------------------------------------------
1061 : SECTION(Element,
1062 : 4, // entry count
1063 : TABLE_INDEX0, // element for table 0
1064 : WASM_INIT_EXPR_I32V_1(0), // index
1065 : 1, // elements count
1066 : FUNC_INDEX(0), // function
1067 : TABLE_INDEX(1), // element for table 1
1068 : WASM_INIT_EXPR_I32V_1(7), // index
1069 : 2, // elements count
1070 : FUNC_INDEX(0), // entry 0
1071 : FUNC_INDEX(0), // entry 1
1072 : TABLE_INDEX(2), // element for table 2
1073 : WASM_INIT_EXPR_I32V_1(12), // index
1074 : 1, // elements count
1075 : FUNC_INDEX(0), // function
1076 : TABLE_INDEX(3), // element for table 1
1077 : WASM_INIT_EXPR_I32V_1(17), // index
1078 : 2, // elements count
1079 : FUNC_INDEX(0), // entry 0
1080 : FUNC_INDEX(0)), // entry 1
1081 : // code ----------------------------------------------------------------
1082 1 : ONE_EMPTY_BODY};
1083 :
1084 4 : EXPECT_VERIFIES(data);
1085 1 : }
1086 :
1087 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionMultipleTablesArbitraryOrder) {
1088 : // Test that the order in which tables are targeted in the element secion
1089 : // can be arbitrary.
1090 1 : WASM_FEATURE_SCOPE(anyref);
1091 1 : WASM_FEATURE_SCOPE(bulk_memory);
1092 : static const byte data[] = {
1093 : // sig#0 ---------------------------------------------------------------
1094 : SIGNATURES_SECTION_VOID_VOID,
1095 : // funcs ---------------------------------------------------------------
1096 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1097 : // table declaration ---------------------------------------------------
1098 : SECTION(Table, ENTRY_COUNT(2), // section header
1099 : kLocalAnyFunc, 0, 5, // table 0
1100 : kLocalAnyFunc, 0, 9), // table 1
1101 : // elements ------------------------------------------------------------
1102 : SECTION(Element,
1103 : ENTRY_COUNT(3), // entry count
1104 : TABLE_INDEX0, // element for table 1
1105 : WASM_INIT_EXPR_I32V_1(0), // index
1106 : 1, // elements count
1107 : FUNC_INDEX(0), // function
1108 : TABLE_INDEX(1), // element for table 0
1109 : WASM_INIT_EXPR_I32V_1(7), // index
1110 : 2, // elements count
1111 : FUNC_INDEX(0), // entry 0
1112 : FUNC_INDEX(0), // entry 1
1113 : TABLE_INDEX0, // element for table 1
1114 : WASM_INIT_EXPR_I32V_1(3), // index
1115 : 1, // elements count
1116 : FUNC_INDEX(0)), // function
1117 : // code ----------------------------------------------------------------
1118 1 : ONE_EMPTY_BODY};
1119 :
1120 4 : EXPECT_VERIFIES(data);
1121 1 : }
1122 :
1123 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionMixedTablesArbitraryOrder) {
1124 : // Test that the order in which tables are targeted in the element secion can
1125 : // be arbitrary. In this test, tables can be both imported and module-defined.
1126 1 : WASM_FEATURE_SCOPE(anyref);
1127 1 : WASM_FEATURE_SCOPE(bulk_memory);
1128 : static const byte data[] = {
1129 : // sig#0 ---------------------------------------------------------------
1130 : SIGNATURES_SECTION_VOID_VOID,
1131 : // imports -------------------------------------------------------------
1132 : SECTION(Import, ENTRY_COUNT(2),
1133 : ADD_COUNT('m'), // module name
1134 : ADD_COUNT('t'), // table name
1135 : kExternalTable, // import kind
1136 : kLocalAnyFunc, // elem_type
1137 : 0, // no maximum field
1138 : 5, // initial size
1139 : ADD_COUNT('m'), // module name
1140 : ADD_COUNT('s'), // table name
1141 : kExternalTable, // import kind
1142 : kLocalAnyFunc, // elem_type
1143 : 0, // no maximum field
1144 : 10), // initial size
1145 : // funcs ---------------------------------------------------------------
1146 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1147 : // table declaration ---------------------------------------------------
1148 : SECTION(Table, ENTRY_COUNT(2), // section header
1149 : kLocalAnyFunc, 0, 15, // table 0
1150 : kLocalAnyFunc, 0, 19), // table 1
1151 : // elements ------------------------------------------------------------
1152 : SECTION(Element,
1153 : 4, // entry count
1154 : TABLE_INDEX(2), // element for table 0
1155 : WASM_INIT_EXPR_I32V_1(10), // index
1156 : 1, // elements count
1157 : FUNC_INDEX(0), // function
1158 : TABLE_INDEX(3), // element for table 1
1159 : WASM_INIT_EXPR_I32V_1(17), // index
1160 : 2, // elements count
1161 : FUNC_INDEX(0), // entry 0
1162 : FUNC_INDEX(0), // entry 1
1163 : TABLE_INDEX0, // element for table 2
1164 : WASM_INIT_EXPR_I32V_1(2), // index
1165 : 1, // elements count
1166 : FUNC_INDEX(0), // function
1167 : TABLE_INDEX(1), // element for table 1
1168 : WASM_INIT_EXPR_I32V_1(7), // index
1169 : 2, // elements count
1170 : FUNC_INDEX(0), // entry 0
1171 : FUNC_INDEX(0)), // entry 1
1172 : // code ----------------------------------------------------------------
1173 1 : ONE_EMPTY_BODY};
1174 :
1175 4 : EXPECT_VERIFIES(data);
1176 1 : }
1177 :
1178 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionDontInitAnyRefTable) {
1179 : // Test that tables of type 'AnyRef' cannot be initialized by the element
1180 : // section.
1181 1 : WASM_FEATURE_SCOPE(anyref);
1182 1 : WASM_FEATURE_SCOPE(bulk_memory);
1183 : static const byte data[] = {
1184 : // sig#0 ---------------------------------------------------------------
1185 : SIGNATURES_SECTION_VOID_VOID,
1186 : // funcs ---------------------------------------------------------------
1187 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1188 : // table declaration ---------------------------------------------------
1189 : SECTION(Table, ENTRY_COUNT(2), // section header
1190 : kLocalAnyRef, 0, 5, // table 0
1191 : kLocalAnyFunc, 0, 9), // table 1
1192 : // elements ------------------------------------------------------------
1193 : SECTION(Element,
1194 : ENTRY_COUNT(2), // entry count
1195 : TABLE_INDEX0, // element for table 0
1196 : WASM_INIT_EXPR_I32V_1(0), // index
1197 : 1, // elements count
1198 : FUNC_INDEX(0), // function
1199 : TABLE_INDEX(1), // element for table 1
1200 : WASM_INIT_EXPR_I32V_1(7), // index
1201 : 2, // elements count
1202 : FUNC_INDEX(0), // entry 0
1203 : FUNC_INDEX(0)), // entry 1
1204 1 : };
1205 :
1206 4 : EXPECT_FAILURE(data);
1207 1 : }
1208 :
1209 15445 : TEST_F(WasmModuleVerifyTest, ElementSectionDontInitAnyRefImportedTable) {
1210 : // Test that imported tables of type AnyRef cannot be initialized in the
1211 : // elements section.
1212 1 : WASM_FEATURE_SCOPE(anyref);
1213 1 : WASM_FEATURE_SCOPE(bulk_memory);
1214 : static const byte data[] = {
1215 : // sig#0 ---------------------------------------------------------------
1216 : SIGNATURES_SECTION_VOID_VOID,
1217 : // imports -------------------------------------------------------------
1218 : SECTION(Import, ENTRY_COUNT(2),
1219 : ADD_COUNT('m'), // module name
1220 : ADD_COUNT('t'), // table name
1221 : kExternalTable, // import kind
1222 : kLocalAnyFunc, // elem_type
1223 : 0, // no maximum field
1224 : 5, // initial size
1225 : ADD_COUNT('m'), // module name
1226 : ADD_COUNT('s'), // table name
1227 : kExternalTable, // import kind
1228 : kLocalAnyRef, // elem_type
1229 : 0, // no maximum field
1230 : 10), // initial size
1231 : // funcs ---------------------------------------------------------------
1232 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1233 : // table declaration ---------------------------------------------------
1234 : SECTION(Table, ENTRY_COUNT(2), // section header
1235 : kLocalAnyFunc, 0, 15, // table 0
1236 : kLocalAnyFunc, 0, 19), // table 1
1237 : // elements ------------------------------------------------------------
1238 : SECTION(Element,
1239 : ENTRY_COUNT(4), // entry count
1240 : TABLE_INDEX0, // element for table 0
1241 : WASM_INIT_EXPR_I32V_1(10), // index
1242 : 1, // elements count
1243 : FUNC_INDEX(0), // function
1244 : TABLE_INDEX(1), // element for table 1
1245 : WASM_INIT_EXPR_I32V_1(17), // index
1246 : 2, // elements count
1247 : FUNC_INDEX(0), // entry 0
1248 : FUNC_INDEX(0)), // entry 1
1249 1 : };
1250 :
1251 4 : EXPECT_FAILURE(data);
1252 1 : }
1253 :
1254 15445 : TEST_F(WasmModuleVerifyTest, IndirectFunctionNoFunctions) {
1255 : static const byte data[] = {
1256 : // sig#0 -------------------------------------------------------
1257 : SIGNATURES_SECTION_VOID_VOID,
1258 : // indirect table ----------------------------------------------
1259 : SECTION(Table, ENTRY_COUNT(1), 1, 0, 0)};
1260 :
1261 4 : EXPECT_FAILURE(data);
1262 1 : }
1263 :
1264 15445 : TEST_F(WasmModuleVerifyTest, IndirectFunctionInvalidIndex) {
1265 : static const byte data[] = {
1266 : // sig#0 -------------------------------------------------------
1267 : SIGNATURES_SECTION_VOID_VOID,
1268 : // functions ---------------------------------------------------
1269 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1270 : // indirect table ----------------------------------------------
1271 : SECTION(Table, ENTRY_COUNT(1), 1, 1, 0)};
1272 :
1273 4 : EXPECT_FAILURE(data);
1274 1 : }
1275 :
1276 15445 : TEST_F(WasmModuleVerifyTest, MultipleTablesWithoutFlag) {
1277 : static const byte data[] = {
1278 : SECTION(Table, // table section
1279 : ENTRY_COUNT(2), // 2 tables
1280 : kLocalAnyFunc, // table 1: type
1281 : 0, // table 1: no maximum
1282 : 10, // table 1: minimum size
1283 : kLocalAnyFunc, // table 2: type
1284 : 0, // table 2: no maximum
1285 : 10), // table 2: minimum size
1286 : };
1287 4 : EXPECT_FAILURE(data);
1288 1 : }
1289 :
1290 15445 : TEST_F(WasmModuleVerifyTest, MultipleTablesWithFlag) {
1291 1 : WASM_FEATURE_SCOPE(anyref);
1292 : static const byte data[] = {
1293 : SECTION(Table, // table section
1294 : ENTRY_COUNT(2), // 2 tables
1295 : kLocalAnyFunc, // table 1: type
1296 : 0, // table 1: no maximum
1297 : 10, // table 1: minimum size
1298 : kLocalAnyRef, // table 2: type
1299 : 0, // table 2: no maximum
1300 : 11), // table 2: minimum size
1301 : };
1302 :
1303 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
1304 2 : EXPECT_OK(result);
1305 :
1306 2 : EXPECT_EQ(2u, result.value()->tables.size());
1307 :
1308 2 : EXPECT_EQ(10u, result.value()->tables[0].initial_size);
1309 2 : EXPECT_EQ(kWasmAnyFunc, result.value()->tables[0].type);
1310 :
1311 2 : EXPECT_EQ(11u, result.value()->tables[1].initial_size);
1312 2 : EXPECT_EQ(kWasmAnyRef, result.value()->tables[1].type);
1313 : }
1314 :
1315 15445 : TEST_F(WasmModuleVerifyTest, TieringCompilationHints) {
1316 1 : WASM_FEATURE_SCOPE(compilation_hints);
1317 : static const byte data[] = {
1318 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v),
1319 : FUNCTION_SIGNATURES_SECTION(3, 0, 0, 0),
1320 : SECTION_COMPILATION_HINTS(
1321 : BASELINE_TIER_INTERPRETER | TOP_TIER_BASELINE,
1322 : BASELINE_TIER_BASELINE | TOP_TIER_OPTIMIZED,
1323 : BASELINE_TIER_INTERPRETER | TOP_TIER_INTERPRETER),
1324 : SECTION(Code, ENTRY_COUNT(3), NOP_BODY, NOP_BODY, NOP_BODY),
1325 : };
1326 :
1327 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
1328 2 : EXPECT_OK(result);
1329 :
1330 2 : EXPECT_EQ(3u, result.value()->compilation_hints.size());
1331 2 : EXPECT_EQ(WasmCompilationHintStrategy::kDefault,
1332 0 : result.value()->compilation_hints[0].strategy);
1333 2 : EXPECT_EQ(WasmCompilationHintTier::kInterpreter,
1334 0 : result.value()->compilation_hints[0].baseline_tier);
1335 2 : EXPECT_EQ(WasmCompilationHintTier::kBaseline,
1336 0 : result.value()->compilation_hints[0].top_tier);
1337 2 : EXPECT_EQ(WasmCompilationHintStrategy::kDefault,
1338 0 : result.value()->compilation_hints[1].strategy);
1339 2 : EXPECT_EQ(WasmCompilationHintTier::kBaseline,
1340 0 : result.value()->compilation_hints[1].baseline_tier);
1341 2 : EXPECT_EQ(WasmCompilationHintTier::kOptimized,
1342 0 : result.value()->compilation_hints[1].top_tier);
1343 2 : EXPECT_EQ(WasmCompilationHintStrategy::kDefault,
1344 0 : result.value()->compilation_hints[2].strategy);
1345 2 : EXPECT_EQ(WasmCompilationHintTier::kInterpreter,
1346 0 : result.value()->compilation_hints[2].baseline_tier);
1347 2 : EXPECT_EQ(WasmCompilationHintTier::kInterpreter,
1348 0 : result.value()->compilation_hints[2].top_tier);
1349 : }
1350 :
1351 28 : class WasmSignatureDecodeTest : public TestWithZone {
1352 : public:
1353 : WasmFeatures enabled_features_;
1354 :
1355 : FunctionSig* DecodeSig(const byte* start, const byte* end) {
1356 262 : return DecodeWasmSignatureForTesting(enabled_features_, zone(), start, end);
1357 : }
1358 : };
1359 :
1360 15444 : TEST_F(WasmSignatureDecodeTest, Ok_v_v) {
1361 : static const byte data[] = {SIG_ENTRY_v_v};
1362 2 : v8::internal::AccountingAllocator allocator;
1363 2 : Zone zone(&allocator, ZONE_NAME);
1364 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1365 :
1366 2 : EXPECT_TRUE(sig != nullptr);
1367 2 : EXPECT_EQ(0u, sig->parameter_count());
1368 2 : EXPECT_EQ(0u, sig->return_count());
1369 1 : }
1370 :
1371 15444 : TEST_F(WasmSignatureDecodeTest, Ok_t_v) {
1372 1 : WASM_FEATURE_SCOPE(anyref);
1373 13 : for (size_t i = 0; i < arraysize(kValueTypes); i++) {
1374 6 : ValueTypePair ret_type = kValueTypes[i];
1375 6 : const byte data[] = {SIG_ENTRY_x(ret_type.code)};
1376 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1377 :
1378 12 : EXPECT_TRUE(sig != nullptr);
1379 12 : EXPECT_EQ(0u, sig->parameter_count());
1380 12 : EXPECT_EQ(1u, sig->return_count());
1381 12 : EXPECT_EQ(ret_type.type, sig->GetReturn());
1382 : }
1383 1 : }
1384 :
1385 15444 : TEST_F(WasmSignatureDecodeTest, Ok_v_t) {
1386 1 : WASM_FEATURE_SCOPE(anyref);
1387 13 : for (size_t i = 0; i < arraysize(kValueTypes); i++) {
1388 6 : ValueTypePair param_type = kValueTypes[i];
1389 6 : const byte data[] = {SIG_ENTRY_v_x(param_type.code)};
1390 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1391 :
1392 12 : EXPECT_TRUE(sig != nullptr);
1393 12 : EXPECT_EQ(1u, sig->parameter_count());
1394 12 : EXPECT_EQ(0u, sig->return_count());
1395 12 : EXPECT_EQ(param_type.type, sig->GetParam(0));
1396 : }
1397 1 : }
1398 :
1399 15444 : TEST_F(WasmSignatureDecodeTest, Ok_t_t) {
1400 1 : WASM_FEATURE_SCOPE(anyref);
1401 13 : for (size_t i = 0; i < arraysize(kValueTypes); i++) {
1402 6 : ValueTypePair ret_type = kValueTypes[i];
1403 78 : for (size_t j = 0; j < arraysize(kValueTypes); j++) {
1404 36 : ValueTypePair param_type = kValueTypes[j];
1405 36 : const byte data[] = {SIG_ENTRY_x_x(ret_type.code, param_type.code)};
1406 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1407 :
1408 72 : EXPECT_TRUE(sig != nullptr);
1409 72 : EXPECT_EQ(1u, sig->parameter_count());
1410 72 : EXPECT_EQ(1u, sig->return_count());
1411 72 : EXPECT_EQ(param_type.type, sig->GetParam(0));
1412 72 : EXPECT_EQ(ret_type.type, sig->GetReturn());
1413 : }
1414 : }
1415 1 : }
1416 :
1417 15444 : TEST_F(WasmSignatureDecodeTest, Ok_i_tt) {
1418 1 : WASM_FEATURE_SCOPE(anyref);
1419 1 : WASM_FEATURE_SCOPE(mv);
1420 13 : for (size_t i = 0; i < arraysize(kValueTypes); i++) {
1421 6 : ValueTypePair p0_type = kValueTypes[i];
1422 78 : for (size_t j = 0; j < arraysize(kValueTypes); j++) {
1423 36 : ValueTypePair p1_type = kValueTypes[j];
1424 : const byte data[] = {
1425 36 : SIG_ENTRY_x_xx(kLocalI32, p0_type.code, p1_type.code)};
1426 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1427 :
1428 72 : EXPECT_TRUE(sig != nullptr);
1429 72 : EXPECT_EQ(2u, sig->parameter_count());
1430 72 : EXPECT_EQ(1u, sig->return_count());
1431 72 : EXPECT_EQ(p0_type.type, sig->GetParam(0));
1432 72 : EXPECT_EQ(p1_type.type, sig->GetParam(1));
1433 : }
1434 : }
1435 1 : }
1436 :
1437 15444 : TEST_F(WasmSignatureDecodeTest, Ok_tt_tt) {
1438 1 : WASM_FEATURE_SCOPE(anyref);
1439 1 : WASM_FEATURE_SCOPE(mv);
1440 13 : for (size_t i = 0; i < arraysize(kValueTypes); i++) {
1441 6 : ValueTypePair p0_type = kValueTypes[i];
1442 78 : for (size_t j = 0; j < arraysize(kValueTypes); j++) {
1443 36 : ValueTypePair p1_type = kValueTypes[j];
1444 72 : const byte data[] = {SIG_ENTRY_xx_xx(p0_type.code, p1_type.code,
1445 108 : p0_type.code, p1_type.code)};
1446 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1447 :
1448 72 : EXPECT_TRUE(sig != nullptr);
1449 72 : EXPECT_EQ(2u, sig->parameter_count());
1450 72 : EXPECT_EQ(2u, sig->return_count());
1451 72 : EXPECT_EQ(p0_type.type, sig->GetParam(0));
1452 72 : EXPECT_EQ(p1_type.type, sig->GetParam(1));
1453 72 : EXPECT_EQ(p0_type.type, sig->GetReturn(0));
1454 72 : EXPECT_EQ(p1_type.type, sig->GetReturn(1));
1455 : }
1456 : }
1457 1 : }
1458 :
1459 15444 : TEST_F(WasmSignatureDecodeTest, TooManyParams) {
1460 : static const byte data[] = {kWasmFunctionTypeCode,
1461 : WASM_I32V_3(kV8MaxWasmFunctionParams + 1),
1462 1 : kLocalI32, 0};
1463 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1464 2 : EXPECT_FALSE(sig != nullptr);
1465 1 : }
1466 :
1467 15444 : TEST_F(WasmSignatureDecodeTest, TooManyReturns) {
1468 5 : for (int i = 0; i < 2; i++) {
1469 2 : bool enable_mv = i != 0;
1470 2 : WASM_FEATURE_SCOPE_VAL(mv, enable_mv);
1471 : const int max_return_count = static_cast<int>(
1472 2 : enable_mv ? kV8MaxWasmFunctionMultiReturns : kV8MaxWasmFunctionReturns);
1473 2 : byte data[] = {kWasmFunctionTypeCode, 0, WASM_I32V_3(max_return_count + 1),
1474 4 : kLocalI32};
1475 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1476 2 : EXPECT_EQ(nullptr, sig);
1477 : }
1478 1 : }
1479 :
1480 15444 : TEST_F(WasmSignatureDecodeTest, Fail_off_end) {
1481 : byte data[256];
1482 11 : for (int p = 0; p <= 255; p = p + 1 + p * 3) {
1483 122 : for (int i = 0; i <= p; i++) data[i] = kLocalI32;
1484 5 : data[0] = static_cast<byte>(p);
1485 :
1486 239 : for (int i = 0; i < p + 1; i++) {
1487 : // Should fall off the end for all signatures.
1488 117 : FunctionSig* sig = DecodeSig(data, data + i);
1489 117 : EXPECT_EQ(nullptr, sig);
1490 : }
1491 : }
1492 1 : }
1493 :
1494 15444 : TEST_F(WasmSignatureDecodeTest, Fail_anyref_without_flag) {
1495 : // Disable AnyRef support and check that decoding fails.
1496 1 : WASM_FEATURE_SCOPE_VAL(anyref, false);
1497 1 : byte ref_types[] = {kLocalAnyFunc, kLocalAnyRef};
1498 5 : for (byte invalid_type : ref_types) {
1499 12 : for (size_t i = 0;; i++) {
1500 14 : byte data[] = {SIG_ENTRY_x_xx(kLocalI32, kLocalI32, kLocalI32)};
1501 14 : if (i >= arraysize(data)) break;
1502 12 : data[i] = invalid_type;
1503 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1504 12 : EXPECT_EQ(nullptr, sig);
1505 : }
1506 : }
1507 1 : }
1508 :
1509 15444 : TEST_F(WasmSignatureDecodeTest, Fail_invalid_type) {
1510 : byte kInvalidType = 76;
1511 6 : for (size_t i = 0;; i++) {
1512 7 : byte data[] = {SIG_ENTRY_x_xx(kLocalI32, kLocalI32, kLocalI32)};
1513 7 : if (i >= arraysize(data)) break;
1514 6 : data[i] = kInvalidType;
1515 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1516 6 : EXPECT_EQ(nullptr, sig);
1517 : }
1518 1 : }
1519 :
1520 15444 : TEST_F(WasmSignatureDecodeTest, Fail_invalid_ret_type1) {
1521 : static const byte data[] = {SIG_ENTRY_x_x(kLocalVoid, kLocalI32)};
1522 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1523 1 : EXPECT_EQ(nullptr, sig);
1524 1 : }
1525 :
1526 15444 : TEST_F(WasmSignatureDecodeTest, Fail_invalid_param_type1) {
1527 : static const byte data[] = {SIG_ENTRY_x_x(kLocalI32, kLocalVoid)};
1528 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1529 1 : EXPECT_EQ(nullptr, sig);
1530 1 : }
1531 :
1532 15444 : TEST_F(WasmSignatureDecodeTest, Fail_invalid_param_type2) {
1533 : static const byte data[] = {SIG_ENTRY_x_xx(kLocalI32, kLocalI32, kLocalVoid)};
1534 : FunctionSig* sig = DecodeSig(data, data + sizeof(data));
1535 1 : EXPECT_EQ(nullptr, sig);
1536 1 : }
1537 :
1538 3 : class WasmFunctionVerifyTest : public TestWithIsolateAndZone {
1539 : public:
1540 1 : FunctionResult DecodeWasmFunction(const ModuleWireBytes& wire_bytes,
1541 : const WasmModule* module,
1542 : const byte* function_start,
1543 : const byte* function_end) {
1544 1 : WasmFeatures enabled_features;
1545 2 : return DecodeWasmFunctionForTesting(enabled_features, zone(), wire_bytes,
1546 : module, function_start, function_end,
1547 1 : isolate()->counters());
1548 : }
1549 : };
1550 :
1551 15444 : TEST_F(WasmFunctionVerifyTest, Ok_v_v_empty) {
1552 : static const byte data[] = {
1553 : SIG_ENTRY_v_v, // signature entry
1554 : 4, // locals
1555 : 3,
1556 : kLocalI32, // --
1557 : 4,
1558 : kLocalI64, // --
1559 : 5,
1560 : kLocalF32, // --
1561 : 6,
1562 : kLocalF64, // --
1563 : kExprEnd // body
1564 : };
1565 :
1566 2 : WasmModule module;
1567 2 : FunctionResult result = DecodeWasmFunction(ModuleWireBytes({}), &module, data,
1568 1 : data + sizeof(data));
1569 2 : EXPECT_OK(result);
1570 :
1571 1 : if (result.value() && result.ok()) {
1572 : WasmFunction* function = result.value().get();
1573 2 : EXPECT_EQ(0u, function->sig->parameter_count());
1574 2 : EXPECT_EQ(0u, function->sig->return_count());
1575 2 : EXPECT_EQ(COUNT_ARGS(SIG_ENTRY_v_v), function->code.offset());
1576 2 : EXPECT_EQ(sizeof(data), function->code.end_offset());
1577 : // TODO(titzer): verify encoding of local declarations
1578 : }
1579 : }
1580 :
1581 15445 : TEST_F(WasmModuleVerifyTest, SectionWithoutNameLength) {
1582 1 : const byte data[] = {1};
1583 4 : EXPECT_FAILURE(data);
1584 1 : }
1585 :
1586 15445 : TEST_F(WasmModuleVerifyTest, TheLoneliestOfValidModulesTheTrulyEmptyOne) {
1587 : const byte data[] = {
1588 : 0, // unknown section code.
1589 : 0, // Empty section name.
1590 : // No section name, no content, nothing but sadness.
1591 : 0, // No section content.
1592 1 : };
1593 4 : EXPECT_VERIFIES(data);
1594 1 : }
1595 :
1596 15445 : TEST_F(WasmModuleVerifyTest, OnlyUnknownSectionEmpty) {
1597 : const byte data[] = {
1598 : UNKNOWN_SECTION(0),
1599 1 : };
1600 4 : EXPECT_VERIFIES(data);
1601 1 : }
1602 :
1603 15445 : TEST_F(WasmModuleVerifyTest, OnlyUnknownSectionNonEmpty) {
1604 : const byte data[] = {
1605 : UNKNOWN_SECTION(5),
1606 : 0xFF,
1607 : 0xFF,
1608 : 0xFF,
1609 : 0xFF,
1610 : 0xFF, // section data
1611 1 : };
1612 4 : EXPECT_VERIFIES(data);
1613 1 : }
1614 :
1615 15445 : TEST_F(WasmModuleVerifyTest, SignatureFollowedByEmptyUnknownSection) {
1616 : const byte data[] = {
1617 : // signatures
1618 : SIGNATURES_SECTION_VOID_VOID,
1619 : // -----------------------------------------------------------
1620 1 : UNKNOWN_SECTION(0)};
1621 4 : EXPECT_VERIFIES(data);
1622 1 : }
1623 :
1624 15445 : TEST_F(WasmModuleVerifyTest, SignatureFollowedByUnknownSection) {
1625 : const byte data[] = {
1626 : // signatures
1627 : SIGNATURES_SECTION_VOID_VOID,
1628 : // -----------------------------------------------------------
1629 : UNKNOWN_SECTION(5), 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1630 1 : };
1631 4 : EXPECT_VERIFIES(data);
1632 1 : }
1633 :
1634 15445 : TEST_F(WasmModuleVerifyTest, UnknownSectionOverflow) {
1635 : static const byte data[] = {
1636 : UNKNOWN_SECTION(9),
1637 : 1,
1638 : 2,
1639 : 3,
1640 : 4,
1641 : 5,
1642 : 6,
1643 : 7,
1644 : 8,
1645 : 9,
1646 : 10, // 10 byte section
1647 : };
1648 4 : EXPECT_FAILURE(data);
1649 1 : }
1650 :
1651 15445 : TEST_F(WasmModuleVerifyTest, UnknownSectionUnderflow) {
1652 : static const byte data[] = {
1653 : UNKNOWN_SECTION(333),
1654 : 1,
1655 : 2,
1656 : 3,
1657 : 4, // 4 byte section
1658 : };
1659 4 : EXPECT_FAILURE(data);
1660 1 : }
1661 :
1662 15445 : TEST_F(WasmModuleVerifyTest, UnknownSectionSkipped) {
1663 : static const byte data[] = {
1664 : UNKNOWN_SECTION(1),
1665 : 0, // one byte section
1666 : SECTION(Global, ENTRY_COUNT(1),
1667 : kLocalI32, // memory type
1668 : 0, // exported
1669 : WASM_INIT_EXPR_I32V_1(33)), // init
1670 1 : };
1671 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
1672 2 : EXPECT_OK(result);
1673 :
1674 2 : EXPECT_EQ(1u, result.value()->globals.size());
1675 2 : EXPECT_EQ(0u, result.value()->functions.size());
1676 2 : EXPECT_EQ(0u, result.value()->data_segments.size());
1677 :
1678 : const WasmGlobal* global = &result.value()->globals.back();
1679 :
1680 2 : EXPECT_EQ(kWasmI32, global->type);
1681 2 : EXPECT_EQ(0u, global->offset);
1682 : }
1683 :
1684 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_empty) {
1685 : static const byte data[] = {SECTION(Type, ENTRY_COUNT(0)),
1686 : SECTION(Import, ENTRY_COUNT(0))};
1687 4 : EXPECT_VERIFIES(data);
1688 1 : }
1689 :
1690 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_nosigs1) {
1691 : static const byte data[] = {SECTION(Import, ENTRY_COUNT(0))};
1692 4 : EXPECT_VERIFIES(data);
1693 1 : }
1694 :
1695 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_mutable_global) {
1696 : {
1697 : static const byte data[] = {
1698 : SECTION(Import, // section header
1699 : ENTRY_COUNT(1), // number of imports
1700 : ADD_COUNT('m'), // module name
1701 : ADD_COUNT('f'), // global name
1702 : kExternalGlobal, // import kind
1703 : kLocalI32, // type
1704 : 0), // mutability
1705 : };
1706 4 : EXPECT_VERIFIES(data);
1707 : }
1708 : {
1709 : static const byte data[] = {
1710 : SECTION(Import, // section header
1711 : ENTRY_COUNT(1), // sig table
1712 : ADD_COUNT('m'), // module name
1713 : ADD_COUNT('f'), // global name
1714 : kExternalGlobal, // import kind
1715 : kLocalI32, // type
1716 : 1), // mutability
1717 : };
1718 4 : EXPECT_VERIFIES(data);
1719 : }
1720 1 : }
1721 :
1722 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_mutability_malformed) {
1723 : static const byte data[] = {
1724 : SECTION(Import,
1725 : ENTRY_COUNT(1), // --
1726 : ADD_COUNT('m'), // module name
1727 : ADD_COUNT('g'), // global name
1728 : kExternalGlobal, // import kind
1729 : kLocalI32, // type
1730 : 2), // invalid mutability
1731 : };
1732 4 : EXPECT_FAILURE(data);
1733 1 : }
1734 :
1735 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_nosigs2) {
1736 : static const byte data[] = {
1737 : SECTION(Import, ENTRY_COUNT(1), // sig table
1738 : ADD_COUNT('m'), // module name
1739 : ADD_COUNT('f'), // function name
1740 : kExternalFunction, // import kind
1741 : SIG_INDEX(0)), // sig index
1742 : };
1743 4 : EXPECT_FAILURE(data);
1744 1 : }
1745 :
1746 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_invalid_sig) {
1747 : static const byte data[] = {
1748 : SECTION(Type, ENTRY_COUNT(0)), // --
1749 : SECTION(Import, ENTRY_COUNT(1), // --
1750 : ADD_COUNT('m'), // module name
1751 : ADD_COUNT('f'), // function name
1752 : kExternalFunction, // import kind
1753 : SIG_INDEX(0)), // sig index
1754 : };
1755 4 : EXPECT_FAILURE(data);
1756 1 : }
1757 :
1758 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_one_sig) {
1759 : static const byte data[] = {
1760 : // signatures
1761 : SIGNATURES_SECTION_VOID_VOID,
1762 : SECTION(Import,
1763 : ENTRY_COUNT(1), // --
1764 : ADD_COUNT('m'), // module name
1765 : ADD_COUNT('f'), // function name
1766 : kExternalFunction, // import kind
1767 : SIG_INDEX(0)), // sig index
1768 : };
1769 4 : EXPECT_VERIFIES(data);
1770 1 : }
1771 :
1772 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_invalid_module) {
1773 : static const byte data[] = {
1774 : // signatures
1775 : SIGNATURES_SECTION_VOID_VOID, // --
1776 : SECTION(Import, // --
1777 : ENTRY_COUNT(1), // --
1778 : NO_NAME, // module name
1779 : ADD_COUNT('f'), // function name
1780 : kExternalFunction, // import kind
1781 : SIG_INDEX(0), // sig index
1782 : 0), // auxiliary data
1783 : };
1784 4 : EXPECT_FAILURE(data);
1785 1 : }
1786 :
1787 15445 : TEST_F(WasmModuleVerifyTest, ImportTable_off_end) {
1788 : static const byte data[] = {
1789 : // signatures
1790 : SIGNATURES_SECTION_VOID_VOID,
1791 : SECTION(Import, ENTRY_COUNT(1),
1792 : ADD_COUNT('m'), // module name
1793 : ADD_COUNT('f'), // function name
1794 : kExternalFunction), // import kind
1795 : SIG_INDEX(0), // sig index (outside import section!)
1796 : };
1797 :
1798 13 : EXPECT_OFF_END_FAILURE(data, arraysize(data) - 3);
1799 1 : }
1800 :
1801 15445 : TEST_F(WasmModuleVerifyTest, ExportTable_empty1) {
1802 : static const byte data[] = { // signatures
1803 : SIGNATURES_SECTION_VOID_VOID, // --
1804 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1805 : SECTION(Export, ENTRY_COUNT(0)), // --
1806 : ONE_EMPTY_BODY};
1807 :
1808 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
1809 2 : EXPECT_OK(result);
1810 :
1811 2 : EXPECT_EQ(1u, result.value()->functions.size());
1812 2 : EXPECT_EQ(0u, result.value()->export_table.size());
1813 : }
1814 :
1815 15445 : TEST_F(WasmModuleVerifyTest, ExportTable_empty2) {
1816 : static const byte data[] = {SECTION(Type, ENTRY_COUNT(0)),
1817 : SECTION(Export, ENTRY_COUNT(0))};
1818 4 : EXPECT_VERIFIES(data);
1819 1 : }
1820 :
1821 15445 : TEST_F(WasmModuleVerifyTest, ExportTable_NoFunctions2) {
1822 : static const byte data[] = {SECTION(Export, ENTRY_COUNT(0))};
1823 4 : EXPECT_VERIFIES(data);
1824 1 : }
1825 :
1826 15445 : TEST_F(WasmModuleVerifyTest, ExportTableOne) {
1827 : static const byte data[] = {
1828 : // signatures
1829 : SIGNATURES_SECTION_VOID_VOID, ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1830 : SECTION(Export,
1831 : ENTRY_COUNT(1), // exports
1832 : NO_NAME, // --
1833 : kExternalFunction, // --
1834 : FUNC_INDEX(0)), // --
1835 : ONE_EMPTY_BODY};
1836 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
1837 2 : EXPECT_OK(result);
1838 :
1839 2 : EXPECT_EQ(1u, result.value()->functions.size());
1840 2 : EXPECT_EQ(1u, result.value()->export_table.size());
1841 : }
1842 :
1843 15445 : TEST_F(WasmModuleVerifyTest, ExportNameWithInvalidStringLength) {
1844 : static const byte data[] = {
1845 : // signatures
1846 : SIGNATURES_SECTION_VOID_VOID, ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1847 : SECTION(Export,
1848 : ENTRY_COUNT(1), // exports
1849 : U32V_1(84), // invalid string length
1850 : 'e', // --
1851 : kExternalFunction, // --
1852 : FUNC_INDEX(0), // --
1853 : 0, 0, 0) // auxiliary data
1854 : };
1855 :
1856 4 : EXPECT_FAILURE(data);
1857 1 : }
1858 :
1859 15445 : TEST_F(WasmModuleVerifyTest, ExportTableTwo) {
1860 : static const byte data[] = {
1861 : // signatures
1862 : SIGNATURES_SECTION_VOID_VOID, ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1863 : SECTION(Export,
1864 : ENTRY_COUNT(2), // exports
1865 : ADD_COUNT('n', 'a', 'm', 'e'), // --
1866 : kExternalFunction, // --
1867 : FUNC_INDEX(0), // --
1868 : ADD_COUNT('n', 'o', 'm'), // --
1869 : kExternalFunction, // --
1870 : FUNC_INDEX(0)), // --
1871 : ONE_EMPTY_BODY};
1872 :
1873 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
1874 2 : EXPECT_OK(result);
1875 :
1876 2 : EXPECT_EQ(1u, result.value()->functions.size());
1877 2 : EXPECT_EQ(2u, result.value()->export_table.size());
1878 : }
1879 :
1880 15445 : TEST_F(WasmModuleVerifyTest, ExportTableThree) {
1881 : static const byte data[] = {
1882 : // signatures
1883 : SIGNATURES_SECTION_VOID_VOID, THREE_EMPTY_FUNCTIONS(SIG_INDEX(0)),
1884 : SECTION(Export,
1885 : ENTRY_COUNT(3), // exports
1886 : ADD_COUNT('a'), // --
1887 : kExternalFunction,
1888 : FUNC_INDEX(0), // --
1889 : ADD_COUNT('b'), // --
1890 : kExternalFunction,
1891 : FUNC_INDEX(1), // --
1892 : ADD_COUNT('c'), // --
1893 : kExternalFunction,
1894 : FUNC_INDEX(2)), // --
1895 : THREE_EMPTY_BODIES};
1896 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
1897 2 : EXPECT_OK(result);
1898 :
1899 2 : EXPECT_EQ(3u, result.value()->functions.size());
1900 2 : EXPECT_EQ(3u, result.value()->export_table.size());
1901 : }
1902 :
1903 15445 : TEST_F(WasmModuleVerifyTest, ExportTableThreeOne) {
1904 13 : for (int i = 0; i < 6; i++) {
1905 : const byte data[] = {
1906 : // signatures
1907 : SIGNATURES_SECTION_VOID_VOID, THREE_EMPTY_FUNCTIONS(SIG_INDEX(0)),
1908 : SECTION(Export,
1909 : ENTRY_COUNT(1), // exports
1910 : ADD_COUNT('e', 'x'), // --
1911 : kExternalFunction,
1912 : FUNC_INDEX(i)), // --
1913 6 : THREE_EMPTY_BODIES};
1914 :
1915 6 : if (i < 3) {
1916 12 : EXPECT_VERIFIES(data);
1917 : } else {
1918 12 : EXPECT_FAILURE(data);
1919 : }
1920 : }
1921 1 : }
1922 :
1923 15445 : TEST_F(WasmModuleVerifyTest, ExportTableOne_off_end) {
1924 : static const byte data[] = {
1925 : // signatures
1926 : SIGNATURES_SECTION_VOID_VOID, ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
1927 : SECTION(Export,
1928 : ENTRY_COUNT(1), // exports
1929 : NO_NAME, // --
1930 : kExternalFunction,
1931 : FUNC_INDEX(0), // --
1932 : 0, 0, 0) // auxiliary data
1933 : };
1934 :
1935 13 : EXPECT_OFF_END_FAILURE(data, arraysize(data) - 3);
1936 1 : }
1937 :
1938 15445 : TEST_F(WasmModuleVerifyTest, Regression_648070) {
1939 : static const byte data[] = {
1940 : SECTION(Type, ENTRY_COUNT(0)), // --
1941 : SECTION(Function, U32V_5(3500228624)) // function count = 3500228624
1942 : }; // --
1943 4 : EXPECT_FAILURE(data);
1944 1 : }
1945 :
1946 15445 : TEST_F(WasmModuleVerifyTest, Regression_738097) {
1947 : // The function body size caused an integer overflow in the module decoder.
1948 : static const byte data[] = {
1949 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
1950 : FUNCTION_SIGNATURES_SECTION(1, 0), // --
1951 : SECTION(Code, // --
1952 : ENTRY_COUNT(1), // --
1953 : U32V_5(0xFFFFFFFF), // function size,
1954 : 0) // No real body
1955 : };
1956 4 : EXPECT_FAILURE(data);
1957 1 : }
1958 :
1959 15445 : TEST_F(WasmModuleVerifyTest, FunctionBodySizeLimit) {
1960 : const uint32_t delta = 3;
1961 6 : for (uint32_t body_size = kV8MaxWasmFunctionSize - delta;
1962 7 : body_size < kV8MaxWasmFunctionSize + delta; body_size++) {
1963 : byte data[] = {
1964 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
1965 : FUNCTION_SIGNATURES_SECTION(1, 0), // --
1966 : kCodeSectionCode, // code section
1967 24 : U32V_5(1 + body_size + 5), // section size
1968 : 1, // # functions
1969 24 : U32V_5(body_size) // body size
1970 54 : };
1971 6 : size_t total = sizeof(data) + body_size;
1972 6 : byte* buffer = reinterpret_cast<byte*>(calloc(1, total));
1973 : memcpy(buffer, data, sizeof(data));
1974 18 : ModuleResult result = DecodeModule(buffer, buffer + total);
1975 6 : if (body_size <= kV8MaxWasmFunctionSize) {
1976 4 : EXPECT_TRUE(result.ok());
1977 : } else {
1978 4 : EXPECT_FALSE(result.ok());
1979 : }
1980 6 : free(buffer);
1981 : }
1982 1 : }
1983 :
1984 15445 : TEST_F(WasmModuleVerifyTest, FunctionBodies_empty) {
1985 : static const byte data[] = {
1986 : EMPTY_SIGNATURES_SECTION, // --
1987 : EMPTY_FUNCTION_SIGNATURES_SECTION, // --
1988 : EMPTY_FUNCTION_BODIES_SECTION // --
1989 : };
1990 4 : EXPECT_VERIFIES(data);
1991 1 : }
1992 :
1993 15445 : TEST_F(WasmModuleVerifyTest, FunctionBodies_one_empty) {
1994 : static const byte data[] = {
1995 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
1996 : FUNCTION_SIGNATURES_SECTION(1, 0), // --
1997 : ONE_EMPTY_BODY // --
1998 : };
1999 4 : EXPECT_VERIFIES(data);
2000 1 : }
2001 :
2002 15445 : TEST_F(WasmModuleVerifyTest, FunctionBodies_one_nop) {
2003 : static const byte data[] = {
2004 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
2005 : FUNCTION_SIGNATURES_SECTION(1, 0), // --
2006 : SECTION(Code, ENTRY_COUNT(1), NOP_BODY) // --
2007 : };
2008 4 : EXPECT_VERIFIES(data);
2009 1 : }
2010 :
2011 15445 : TEST_F(WasmModuleVerifyTest, FunctionBodies_count_mismatch1) {
2012 : static const byte data[] = {
2013 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
2014 : FUNCTION_SIGNATURES_SECTION(2, 0, 0), // --
2015 : ONE_EMPTY_BODY // --
2016 : };
2017 4 : EXPECT_FAILURE(data);
2018 1 : }
2019 :
2020 15445 : TEST_F(WasmModuleVerifyTest, FunctionBodies_count_mismatch2) {
2021 : static const byte data[] = {
2022 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
2023 : FUNCTION_SIGNATURES_SECTION(1, 0), // --
2024 : SECTION(Code, ENTRY_COUNT(2), NOP_BODY, NOP_BODY) // --
2025 : };
2026 4 : EXPECT_FAILURE(data);
2027 1 : }
2028 :
2029 15445 : TEST_F(WasmModuleVerifyTest, Names_empty) {
2030 : static const byte data[] = {
2031 : EMPTY_SIGNATURES_SECTION, EMPTY_FUNCTION_SIGNATURES_SECTION,
2032 : EMPTY_FUNCTION_BODIES_SECTION, EMPTY_NAMES_SECTION};
2033 4 : EXPECT_VERIFIES(data);
2034 1 : }
2035 :
2036 15445 : TEST_F(WasmModuleVerifyTest, Names_one_empty) {
2037 : // TODO(wasm): This test does not test anything (corrupt name section does not
2038 : // fail validation).
2039 : static const byte data[] = {
2040 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
2041 : FUNCTION_SIGNATURES_SECTION(1, 0), // --
2042 : ONE_EMPTY_BODY, // --
2043 : SECTION_NAMES(ENTRY_COUNT(1), FOO_STRING, NO_LOCAL_NAMES) // --
2044 : };
2045 4 : EXPECT_VERIFIES(data);
2046 1 : }
2047 :
2048 15445 : TEST_F(WasmModuleVerifyTest, Names_two_empty) {
2049 : // TODO(wasm): This test does not test anything (corrupt name section does not
2050 : // fail validation).
2051 : static const byte data[] = {
2052 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // --
2053 : FUNCTION_SIGNATURES_SECTION(2, 0, 0), // --
2054 : TWO_EMPTY_BODIES, // --
2055 : SECTION_NAMES(ENTRY_COUNT(2), // --
2056 : FOO_STRING, NO_LOCAL_NAMES, // --
2057 : FOO_STRING, NO_LOCAL_NAMES), // --
2058 : };
2059 4 : EXPECT_VERIFIES(data);
2060 1 : }
2061 :
2062 15445 : TEST_F(WasmModuleVerifyTest, Regression684855) {
2063 : static const byte data[] = {
2064 : SECTION_NAMES(0xFB, // functions count
2065 : 0x27, // |
2066 : 0x00, // function name length
2067 : 0xFF, // local names count
2068 : 0xFF, // |
2069 : 0xFF, // |
2070 : 0xFF, // |
2071 : 0xFF, // |
2072 : 0xFF, // error: "varint too large"
2073 : 0xFF, // |
2074 : 0x00, // --
2075 : 0x00) // --
2076 : };
2077 4 : EXPECT_VERIFIES(data);
2078 1 : }
2079 :
2080 15445 : TEST_F(WasmModuleVerifyTest, FunctionSectionWithoutCodeSection) {
2081 : static const byte data[] = {
2082 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // Type section.
2083 : FUNCTION_SIGNATURES_SECTION(1, 0), // Function section.
2084 : };
2085 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2086 6 : EXPECT_NOT_OK(result, "function count is 1, but code section is absent");
2087 1 : }
2088 :
2089 15445 : TEST_F(WasmModuleVerifyTest, CodeSectionWithoutFunctionSection) {
2090 : static const byte data[] = {ONE_EMPTY_BODY};
2091 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2092 6 : EXPECT_NOT_OK(result, "function body count 1 mismatch (0 expected)");
2093 1 : }
2094 :
2095 15445 : TEST_F(WasmModuleVerifyTest, EmptyFunctionSectionWithoutCodeSection) {
2096 : static const byte data[] = {SECTION(Function, ENTRY_COUNT(0))};
2097 4 : EXPECT_VERIFIES(data);
2098 1 : }
2099 :
2100 15445 : TEST_F(WasmModuleVerifyTest, EmptyCodeSectionWithoutFunctionSection) {
2101 : static const byte data[] = {SECTION(Code, ENTRY_COUNT(0))};
2102 4 : EXPECT_VERIFIES(data);
2103 1 : }
2104 :
2105 6 : class WasmInitExprDecodeTest : public TestWithZone {
2106 : public:
2107 6 : WasmInitExprDecodeTest() = default;
2108 :
2109 : WasmFeatures enabled_features_;
2110 :
2111 : WasmInitExpr DecodeInitExpr(const byte* start, const byte* end) {
2112 22 : return DecodeWasmInitExprForTesting(enabled_features_, start, end);
2113 : }
2114 : };
2115 :
2116 : #define EXPECT_INIT_EXPR(Type, type, value, ...) \
2117 : { \
2118 : static const byte data[] = {__VA_ARGS__, kExprEnd}; \
2119 : WasmInitExpr expr = DecodeInitExpr(data, data + sizeof(data)); \
2120 : EXPECT_EQ(WasmInitExpr::k##Type##Const, expr.kind); \
2121 : EXPECT_EQ(value, expr.val.type##_const); \
2122 : }
2123 :
2124 : #define EXPECT_INIT_EXPR_FAIL(...) \
2125 : { \
2126 : static const byte data[] = {__VA_ARGS__, kExprEnd}; \
2127 : WasmInitExpr expr = DecodeInitExpr(data, data + sizeof(data)); \
2128 : EXPECT_EQ(WasmInitExpr::kNone, expr.kind); \
2129 : }
2130 :
2131 15444 : TEST_F(WasmInitExprDecodeTest, InitExpr_i32) {
2132 5 : EXPECT_INIT_EXPR(I32, i32, 33, WASM_I32V_1(33));
2133 5 : EXPECT_INIT_EXPR(I32, i32, -21, WASM_I32V_1(-21));
2134 5 : EXPECT_INIT_EXPR(I32, i32, 437, WASM_I32V_2(437));
2135 5 : EXPECT_INIT_EXPR(I32, i32, 77777, WASM_I32V_3(77777));
2136 1 : }
2137 :
2138 15444 : TEST_F(WasmInitExprDecodeTest, InitExpr_f32) {
2139 5 : EXPECT_INIT_EXPR(F32, f32, static_cast<float>(13.1), WASM_F32(13.1));
2140 5 : EXPECT_INIT_EXPR(F32, f32, static_cast<float>(-21.1), WASM_F32(-21.1));
2141 5 : EXPECT_INIT_EXPR(F32, f32, static_cast<float>(437.2), WASM_F32(437.2));
2142 5 : EXPECT_INIT_EXPR(F32, f32, static_cast<float>(77777.3), WASM_F32(77777.3));
2143 1 : }
2144 :
2145 15444 : TEST_F(WasmInitExprDecodeTest, InitExpr_i64) {
2146 5 : EXPECT_INIT_EXPR(I64, i64, 33, WASM_I64V_1(33));
2147 5 : EXPECT_INIT_EXPR(I64, i64, -21, WASM_I64V_2(-21));
2148 5 : EXPECT_INIT_EXPR(I64, i64, 437, WASM_I64V_5(437));
2149 5 : EXPECT_INIT_EXPR(I64, i64, 77777, WASM_I64V_7(77777));
2150 1 : }
2151 :
2152 15444 : TEST_F(WasmInitExprDecodeTest, InitExpr_f64) {
2153 5 : EXPECT_INIT_EXPR(F64, f64, 83.22, WASM_F64(83.22));
2154 5 : EXPECT_INIT_EXPR(F64, f64, -771.3, WASM_F64(-771.3));
2155 5 : EXPECT_INIT_EXPR(F64, f64, 43703.0, WASM_F64(43703.0));
2156 5 : EXPECT_INIT_EXPR(F64, f64, 77999.1, WASM_F64(77999.1));
2157 1 : }
2158 :
2159 15444 : TEST_F(WasmInitExprDecodeTest, InitExpr_AnyRef) {
2160 1 : WASM_FEATURE_SCOPE(anyref);
2161 : static const byte data[] = {kExprRefNull, kExprEnd};
2162 1 : WasmInitExpr expr = DecodeInitExpr(data, data + sizeof(data));
2163 2 : EXPECT_EQ(WasmInitExpr::kRefNullConst, expr.kind);
2164 1 : }
2165 :
2166 15444 : TEST_F(WasmInitExprDecodeTest, InitExpr_illegal) {
2167 3 : EXPECT_INIT_EXPR_FAIL(WASM_I32V_1(0), WASM_I32V_1(0));
2168 2 : EXPECT_INIT_EXPR_FAIL(WASM_GET_LOCAL(0));
2169 3 : EXPECT_INIT_EXPR_FAIL(WASM_SET_LOCAL(0, WASM_I32V_1(0)));
2170 3 : EXPECT_INIT_EXPR_FAIL(WASM_I32_ADD(WASM_I32V_1(0), WASM_I32V_1(0)));
2171 2 : EXPECT_INIT_EXPR_FAIL(WASM_IF_ELSE(WASM_ZERO, WASM_ZERO, WASM_ZERO));
2172 1 : }
2173 :
2174 15445 : TEST_F(WasmModuleVerifyTest, Multiple_Named_Sections) {
2175 : static const byte data[] = {
2176 : SECTION(Unknown, ADD_COUNT('X'), 17, 18), // --
2177 : SECTION(Unknown, ADD_COUNT('f', 'o', 'o'), 5, 6, 7, 8, 9), // --
2178 : SECTION(Unknown, ADD_COUNT('o', 't', 'h', 'e', 'r'), 7, 8), // --
2179 : };
2180 4 : EXPECT_VERIFIES(data);
2181 1 : }
2182 :
2183 15445 : TEST_F(WasmModuleVerifyTest, Section_Name_No_UTF8) {
2184 : static const byte data[] = {SECTION(Unknown, 1, 0xFF, 17, 18)};
2185 4 : EXPECT_FAILURE(data);
2186 1 : }
2187 :
2188 6 : class WasmModuleCustomSectionTest : public TestWithIsolateAndZone {
2189 : public:
2190 2 : void CheckSections(const byte* module_start, const byte* module_end,
2191 : const CustomSectionOffset* expected, size_t num_expected) {
2192 : std::vector<CustomSectionOffset> custom_sections =
2193 2 : DecodeCustomSections(module_start, module_end);
2194 :
2195 2 : CHECK_EQ(num_expected, custom_sections.size());
2196 :
2197 12 : for (size_t i = 0; i < num_expected; i++) {
2198 10 : EXPECT_EQ(expected[i].section.offset(),
2199 0 : custom_sections[i].section.offset());
2200 10 : EXPECT_EQ(expected[i].section.length(),
2201 0 : custom_sections[i].section.length());
2202 10 : EXPECT_EQ(expected[i].name.offset(), custom_sections[i].name.offset());
2203 10 : EXPECT_EQ(expected[i].name.length(), custom_sections[i].name.length());
2204 10 : EXPECT_EQ(expected[i].payload.offset(),
2205 0 : custom_sections[i].payload.offset());
2206 10 : EXPECT_EQ(expected[i].payload.length(),
2207 0 : custom_sections[i].payload.length());
2208 : }
2209 2 : }
2210 : };
2211 :
2212 15444 : TEST_F(WasmModuleCustomSectionTest, ThreeUnknownSections) {
2213 : static constexpr byte data[] = {
2214 : U32_LE(kWasmMagic), // --
2215 : U32_LE(kWasmVersion), // --
2216 : SECTION(Unknown, 1, 'X', 17, 18), // --
2217 : SECTION(Unknown, 3, 'f', 'o', 'o', 5, 6, 7, 8, 9), // --
2218 : SECTION(Unknown, 5, 'o', 't', 'h', 'e', 'r', 7, 8), // --
2219 : };
2220 :
2221 : static const CustomSectionOffset expected[] = {
2222 : // section, name, payload
2223 : {{10, 4}, {11, 1}, {12, 2}}, // --
2224 : {{16, 9}, {17, 3}, {20, 5}}, // --
2225 : {{27, 8}, {28, 5}, {33, 2}}, // --
2226 2 : };
2227 :
2228 1 : CheckSections(data, data + sizeof(data), expected, arraysize(expected));
2229 1 : }
2230 :
2231 15444 : TEST_F(WasmModuleCustomSectionTest, TwoKnownTwoUnknownSections) {
2232 : static const byte data[] = {
2233 : U32_LE(kWasmMagic), // --
2234 : U32_LE(kWasmVersion), // --
2235 : SIGNATURES_SECTION(2, SIG_ENTRY_v_v, SIG_ENTRY_v_v), // --
2236 : SECTION(Unknown, ADD_COUNT('X'), 17, 18), // --
2237 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)), // --
2238 : SECTION(Unknown, ADD_COUNT('o', 't', 'h', 'e', 'r'), 7, 8), // --
2239 : };
2240 :
2241 : static const CustomSectionOffset expected[] = {
2242 : // section, name, payload
2243 : {{19, 4}, {20, 1}, {21, 2}}, // --
2244 : {{29, 8}, {30, 5}, {35, 2}}, // --
2245 2 : };
2246 :
2247 1 : CheckSections(data, data + sizeof(data), expected, arraysize(expected));
2248 1 : }
2249 :
2250 15445 : TEST_F(WasmModuleVerifyTest, SourceMappingURLSection) {
2251 : static const byte data[] = {
2252 : SECTION_SRC_MAP('s', 'r', 'c', '/', 'x', 'y', 'z', '.', 'c')};
2253 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2254 1 : EXPECT_TRUE(result.ok());
2255 2 : EXPECT_EQ("src/xyz.c", result.value()->source_map_url);
2256 1 : }
2257 :
2258 15445 : TEST_F(WasmModuleVerifyTest, BadSourceMappingURLSection) {
2259 : static const byte data[] = {
2260 : SECTION_SRC_MAP('s', 'r', 'c', '/', 'x', 0xff, 'z', '.', 'c')};
2261 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2262 1 : EXPECT_TRUE(result.ok());
2263 2 : EXPECT_EQ(0u, result.value()->source_map_url.size());
2264 1 : }
2265 :
2266 15445 : TEST_F(WasmModuleVerifyTest, MultipleSourceMappingURLSections) {
2267 : static const byte data[] = {SECTION_SRC_MAP('a', 'b', 'c'),
2268 : SECTION_SRC_MAP('p', 'q', 'r')};
2269 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2270 1 : EXPECT_TRUE(result.ok());
2271 2 : EXPECT_EQ("abc", result.value()->source_map_url);
2272 1 : }
2273 :
2274 15445 : TEST_F(WasmModuleVerifyTest, MultipleNameSections) {
2275 : static const byte data[] = {
2276 : SECTION_NAMES(0, ADD_COUNT(ADD_COUNT('a', 'b', 'c'))),
2277 : SECTION_NAMES(0, ADD_COUNT(ADD_COUNT('p', 'q', 'r', 's')))};
2278 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2279 1 : EXPECT_TRUE(result.ok());
2280 2 : EXPECT_EQ(3u, result.value()->name.length());
2281 1 : }
2282 :
2283 15445 : TEST_F(WasmModuleVerifyTest, PassiveDataSegment) {
2284 : static const byte data[] = {
2285 : // memory declaration ----------------------------------------------------
2286 : SECTION(Memory, ENTRY_COUNT(1), 0, 1),
2287 : // data segments --------------------------------------------------------
2288 : SECTION(Data, ENTRY_COUNT(1), PASSIVE, ADD_COUNT('h', 'i')),
2289 : };
2290 4 : EXPECT_FAILURE(data);
2291 1 : WASM_FEATURE_SCOPE(bulk_memory);
2292 4 : EXPECT_VERIFIES(data);
2293 21 : EXPECT_OFF_END_FAILURE(data, arraysize(data) - 5);
2294 1 : }
2295 :
2296 15445 : TEST_F(WasmModuleVerifyTest, PassiveElementSegment) {
2297 : static const byte data[] = {
2298 : // sig#0 -----------------------------------------------------------------
2299 : SIGNATURES_SECTION_VOID_VOID,
2300 : // funcs -----------------------------------------------------------------
2301 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
2302 : // table declaration -----------------------------------------------------
2303 : SECTION(Table, ENTRY_COUNT(1), kLocalAnyFunc, 0, 1),
2304 : // element segments -----------------------------------------------------
2305 : SECTION(Element, ENTRY_COUNT(1), PASSIVE, kLocalAnyFunc, U32V_1(3),
2306 : REF_FUNC_ELEMENT(0), REF_FUNC_ELEMENT(0), REF_NULL_ELEMENT),
2307 : // code ------------------------------------------------------------------
2308 : ONE_EMPTY_BODY};
2309 4 : EXPECT_FAILURE(data);
2310 1 : WASM_FEATURE_SCOPE(bulk_memory);
2311 4 : EXPECT_VERIFIES(data);
2312 21 : EXPECT_OFF_END_FAILURE(data, arraysize(data) - 5);
2313 1 : }
2314 :
2315 15445 : TEST_F(WasmModuleVerifyTest, PassiveElementSegmentAnyRef) {
2316 : static const byte data[] = {
2317 : // sig#0 -----------------------------------------------------------------
2318 : SIGNATURES_SECTION_VOID_VOID,
2319 : // funcs -----------------------------------------------------------------
2320 : ONE_EMPTY_FUNCTION(SIG_INDEX(0)),
2321 : // table declaration -----------------------------------------------------
2322 : SECTION(Table, ENTRY_COUNT(1), kLocalAnyFunc, 0, 1),
2323 : // element segments -----------------------------------------------------
2324 : SECTION(Element, ENTRY_COUNT(1), PASSIVE, kLocalAnyRef, U32V_1(0)),
2325 : // code ------------------------------------------------------------------
2326 : ONE_EMPTY_BODY};
2327 1 : WASM_FEATURE_SCOPE(bulk_memory);
2328 4 : EXPECT_FAILURE(data);
2329 1 : }
2330 :
2331 15445 : TEST_F(WasmModuleVerifyTest, DataCountSectionCorrectPlacement) {
2332 : static const byte data[] = {SECTION(Element, ENTRY_COUNT(0)),
2333 : SECTION(DataCount, ENTRY_COUNT(0)),
2334 : SECTION(Code, ENTRY_COUNT(0))};
2335 4 : EXPECT_FAILURE(data);
2336 1 : WASM_FEATURE_SCOPE(bulk_memory);
2337 4 : EXPECT_VERIFIES(data);
2338 1 : }
2339 :
2340 15445 : TEST_F(WasmModuleVerifyTest, DataCountSectionAfterCode) {
2341 : static const byte data[] = {SECTION(Code, ENTRY_COUNT(0)),
2342 : SECTION(DataCount, ENTRY_COUNT(0))};
2343 1 : WASM_FEATURE_SCOPE(bulk_memory);
2344 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2345 6 : EXPECT_NOT_OK(result,
2346 : "The DataCount section must appear before the Code section");
2347 1 : }
2348 :
2349 15445 : TEST_F(WasmModuleVerifyTest, DataCountSectionBeforeElement) {
2350 : static const byte data[] = {SECTION(DataCount, ENTRY_COUNT(0)),
2351 : SECTION(Element, ENTRY_COUNT(0))};
2352 1 : WASM_FEATURE_SCOPE(bulk_memory);
2353 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2354 6 : EXPECT_NOT_OK(result, "unexpected section <Element>");
2355 1 : }
2356 :
2357 15445 : TEST_F(WasmModuleVerifyTest, DataCountSectionAfterStartBeforeElement) {
2358 : STATIC_ASSERT(kStartSectionCode + 1 == kElementSectionCode);
2359 : static const byte data[] = {
2360 : // We need the start section for this test, but the start section must
2361 : // reference a valid function, which requires the type and function
2362 : // sections too.
2363 : SIGNATURES_SECTION(1, SIG_ENTRY_v_v), // Type section.
2364 : FUNCTION_SIGNATURES_SECTION(1, 0), // Function section.
2365 :
2366 : SECTION(Start, U32V_1(0)), // Start section.
2367 : SECTION(DataCount, ENTRY_COUNT(0)), // DataCount section.
2368 : SECTION(Element, ENTRY_COUNT(0)) // Element section.
2369 : };
2370 1 : WASM_FEATURE_SCOPE(bulk_memory);
2371 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2372 6 : EXPECT_NOT_OK(result, "unexpected section <Element>");
2373 1 : }
2374 :
2375 15445 : TEST_F(WasmModuleVerifyTest, MultipleDataCountSections) {
2376 : static const byte data[] = {SECTION(DataCount, ENTRY_COUNT(0)),
2377 : SECTION(DataCount, ENTRY_COUNT(0))};
2378 1 : WASM_FEATURE_SCOPE(bulk_memory);
2379 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2380 6 : EXPECT_NOT_OK(result, "Multiple DataCount sections not allowed");
2381 1 : }
2382 :
2383 15445 : TEST_F(WasmModuleVerifyTest, DataCountSegmentCountMatch) {
2384 : static const byte data[] = {
2385 : SECTION(Memory, ENTRY_COUNT(1), 0, 1), // Memory section.
2386 : SECTION(DataCount, ENTRY_COUNT(1)), // DataCount section.
2387 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0, // Data section.
2388 1 : WASM_INIT_EXPR_I32V_1(12), ADD_COUNT('h', 'i'))};
2389 :
2390 4 : EXPECT_FAILURE(data);
2391 1 : WASM_FEATURE_SCOPE(bulk_memory);
2392 4 : EXPECT_VERIFIES(data);
2393 1 : }
2394 :
2395 15445 : TEST_F(WasmModuleVerifyTest, DataCountSegmentCount_greater) {
2396 : static const byte data[] = {
2397 : SECTION(Memory, ENTRY_COUNT(1), 0, 1), // Memory section.
2398 : SECTION(DataCount, ENTRY_COUNT(3)), // DataCount section.
2399 : SECTION(Data, ENTRY_COUNT(0))}; // Data section.
2400 1 : WASM_FEATURE_SCOPE(bulk_memory);
2401 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2402 6 : EXPECT_NOT_OK(result, "data segments count 0 mismatch (3 expected)");
2403 1 : }
2404 :
2405 15445 : TEST_F(WasmModuleVerifyTest, DataCountSegmentCount_less) {
2406 : static const byte data[] = {
2407 : SECTION(Memory, ENTRY_COUNT(1), 0, 1), // Memory section.
2408 : SECTION(DataCount, ENTRY_COUNT(0)), // DataCount section.
2409 : SECTION(Data, ENTRY_COUNT(1), LINEAR_MEMORY_INDEX_0, // Data section.
2410 1 : WASM_INIT_EXPR_I32V_1(12), ADD_COUNT('a', 'b', 'c'))};
2411 1 : WASM_FEATURE_SCOPE(bulk_memory);
2412 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2413 6 : EXPECT_NOT_OK(result, "data segments count 1 mismatch (0 expected)");
2414 1 : }
2415 :
2416 15445 : TEST_F(WasmModuleVerifyTest, DataCountSegmentCount_omitted) {
2417 : static const byte data[] = {SECTION(Memory, ENTRY_COUNT(1), 0, 1),
2418 : SECTION(DataCount, ENTRY_COUNT(1))};
2419 1 : WASM_FEATURE_SCOPE(bulk_memory);
2420 3 : ModuleResult result = DecodeModule(data, data + sizeof(data));
2421 6 : EXPECT_NOT_OK(result, "data segments count 0 mismatch (1 expected)");
2422 1 : }
2423 :
2424 : #undef WASM_FEATURE_SCOPE
2425 : #undef WASM_FEATURE_SCOPE_VAL
2426 : #undef EXPECT_INIT_EXPR
2427 : #undef EXPECT_INIT_EXPR_FAIL
2428 : #undef WASM_INIT_EXPR_I32V_1
2429 : #undef WASM_INIT_EXPR_I32V_2
2430 : #undef WASM_INIT_EXPR_I32V_3
2431 : #undef WASM_INIT_EXPR_I32V_4
2432 : #undef WASM_INIT_EXPR_I32V_5
2433 : #undef WASM_INIT_EXPR_F32
2434 : #undef WASM_INIT_EXPR_I64
2435 : #undef WASM_INIT_EXPR_F64
2436 : #undef WASM_INIT_EXPR_ANYREF
2437 : #undef WASM_INIT_EXPR_GLOBAL
2438 : #undef REF_NULL_ELEMENT
2439 : #undef REF_FUNC_ELEMENT
2440 : #undef EMPTY_BODY
2441 : #undef NOP_BODY
2442 : #undef SIG_ENTRY_i_i
2443 : #undef UNKNOWN_SECTION
2444 : #undef COUNT_ARGS
2445 : #undef CHECK_LEB1
2446 : #undef ADD_COUNT
2447 : #undef SECTION
2448 : #undef SIGNATURES_SECTION
2449 : #undef FUNCTION_SIGNATURES_SECTION
2450 : #undef FOO_STRING
2451 : #undef NO_LOCAL_NAMES
2452 : #undef EMPTY_SIGNATURES_SECTION
2453 : #undef EMPTY_FUNCTION_SIGNATURES_SECTION
2454 : #undef EMPTY_FUNCTION_BODIES_SECTION
2455 : #undef SECTION_NAMES
2456 : #undef EMPTY_NAMES_SECTION
2457 : #undef SECTION_SRC_MAP
2458 : #undef SECTION_COMPILATION_HINTS
2459 : #undef FAIL_IF_NO_EXPERIMENTAL_EH
2460 : #undef X1
2461 : #undef X2
2462 : #undef X3
2463 : #undef X4
2464 : #undef ONE_EMPTY_FUNCTION
2465 : #undef TWO_EMPTY_FUNCTIONS
2466 : #undef THREE_EMPTY_FUNCTIONS
2467 : #undef FOUR_EMPTY_FUNCTIONS
2468 : #undef ONE_EMPTY_BODY
2469 : #undef TWO_EMPTY_BODIES
2470 : #undef THREE_EMPTY_BODIES
2471 : #undef FOUR_EMPTY_BODIES
2472 : #undef SIGNATURES_SECTION_VOID_VOID
2473 : #undef LINEAR_MEMORY_INDEX_0
2474 : #undef EXCEPTION_ENTRY
2475 : #undef EXPECT_VERIFIES
2476 : #undef EXPECT_FAILURE_LEN
2477 : #undef EXPECT_FAILURE
2478 : #undef EXPECT_OFF_END_FAILURE
2479 : #undef EXPECT_OK
2480 : #undef EXPECT_NOT_OK
2481 :
2482 : } // namespace module_decoder_unittest
2483 : } // namespace wasm
2484 : } // namespace internal
2485 9264 : } // namespace v8
|
