LCOV - code coverage report
Current view: top level - test/unittests/wasm - module-decoder-unittest.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 841 845 99.5 %
Date: 2019-01-20 Functions: 279 425 65.6 %

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

Generated by: LCOV version 1.10