[wasm] Enforce strict ordering of WASM module sections.

test/unittests/wasm/module-decoder-unittest.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "test/unittests/test-utils.h"
 
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 #define EMPTY_FUNCTION(sig_index) 0, SIG_INDEX(sig_index), U16_LE(0)
 #define EMPTY_FUNCTION_SIZE ((size_t)5)
 #define EMPTY_BODY 0
 #define EMPTY_BODY_SIZE ((size_t)1)
 #define NOP_BODY 2, 0, kExprNop
 #define NOP_BODY_SIZE ((size_t)3)
 #define VOID_VOID_SIG 0, kLocalVoid
 #define VOID_VOID_SIG_SIZE ((size_t)2)
 #define INT_INT_SIG 1, kLocalI32, kLocalI32
 #define INT_INT_SIG_SIZE ((size_t)3)
 
+// TODO(titzer): tricky size logic! Remove -1.
 #define SECTION(NAME, EXTRA_SIZE) \
   U32V_1(WASM_SECTION_##NAME##_SIZE + (EXTRA_SIZE)), WASM_SECTION_##NAME
 
 #define EXPECT_VERIFIES(data)                                         \
   do {                                                                \
     ModuleResult result = DecodeModule(data, data + arraysize(data)); \
     EXPECT_TRUE(result.ok());                                         \
     if (result.val) delete result.val;                                \
   } while (false)
 
 #define EXPECT_FAILURE_LEN(data, length)                     \
   do {                                                       \
     ModuleResult result = DecodeModule(data, data + length); \
     EXPECT_FALSE(result.ok());                               \
     if (result.val) delete result.val;                       \
   } while (false)
 
 #define EXPECT_FAILURE(data) EXPECT_FAILURE_LEN(data, sizeof(data))
 
 #define EXPECT_OFF_END_FAILURE(data, min, max)          \
   do {                                                  \
     for (size_t length = min; length < max; length++) { \
       EXPECT_FAILURE_LEN(data, length);                 \
     }                                                   \
   } while (false)
 
+#define EXPECT_OK(result)                \
+  do {                                   \
+    EXPECT_TRUE(result.ok());            \
+    if (!result.ok()) {                  \
+      if (result.val) delete result.val; \
+      return;                            \
+    }                                    \
+  } while (false)
+
 static size_t SizeOfVarInt(size_t value) {
   size_t size = 0;
   do {
     size++;
     value = value >> 7;
   } while (value > 0);
   return size;
 }
 
 struct LocalTypePair {
@@ skipping 46 matching lines @@
   }
 }
 
 TEST_F(WasmModuleVerifyTest, DecodeEmpty) {
   static const byte data[] = {SECTION(END, 0)};
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, OneGlobal) {
   static const byte data[] = {
-      SECTION(GLOBALS, 7),  // --
+      SECTION(GLOBALS, 5),  // --
       1,
       NAME_LENGTH(1),
       'g',      // name
       kMemI32,  // memory type
       0,        // exported
   };
 
   {
     // Should decode to exactly one global.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(1, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(0, result.val->data_segments.size());
 
     WasmGlobal* global = &result.val->globals.back();
 
     EXPECT_EQ(1, global->name_length);
     EXPECT_EQ(MachineType::Int32(), global->type);
     EXPECT_EQ(0, global->offset);
     EXPECT_FALSE(global->exported);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
   static const byte data[] = {
       SECTION(GLOBALS, 1),  // --
       0,                    // declare 0 globals
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   if (result.val) delete result.val;
 }
 
 
 static void AppendUint32v(std::vector<byte>& buffer, uint32_t val) {
   while (true) {
     uint32_t next = val >> 7;
     uint32_t out = val & 0x7f;
     if (next) {
       buffer.push_back(static_cast<byte>(0x80 | out));
@@ skipping 20 matching lines @@
     const byte globals[] = {U32V_5(size), WASM_SECTION_GLOBALS};
     for (size_t g = 0; g != sizeof(globals); ++g) {
       buffer.push_back(globals[g]);
     }
     AppendUint32v(buffer, i);  // Number of globals.
     for (uint32_t j = 0; j < i; j++) {
       buffer.insert(buffer.end(), data, data + sizeof(data));
     }
 
     ModuleResult result = DecodeModule(&buffer[0], &buffer[0] + buffer.size());
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     if (result.val) delete result.val;
   }
 }
 
 TEST_F(WasmModuleVerifyTest, GlobalWithInvalidNameOffset) {
   static const byte data[] = {
       SECTION(GLOBALS, 7),
       1,        // declare one global
       NO_NAME,  // name offset
       33,       // memory type
@@ skipping 11 matching lines @@
       33,       // memory type
       0,        // exported
   };
 
   EXPECT_FAILURE(data);
 }
 
 
 TEST_F(WasmModuleVerifyTest, TwoGlobals) {
   static const byte data[] = {
-      SECTION(GLOBALS, 13),
+      SECTION(GLOBALS, 7),
       2,
       NO_NAME,  // #0: name length
       kMemF32,  // memory type
       0,        // exported
       NO_NAME,  // #1: name length
       kMemF64,  // memory type
       1,        // exported
   };
 
   {
     // Should decode to exactly two globals.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(2, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(0, result.val->data_segments.size());
 
     WasmGlobal* g0 = &result.val->globals[0];
     WasmGlobal* g1 = &result.val->globals[1];
 
     EXPECT_EQ(0, g0->name_length);
     EXPECT_EQ(MachineType::Float32(), g0->type);
     EXPECT_EQ(0, g0->offset);
@@ skipping 35 matching lines @@
       1,
       kLocalI32,
       kLocalF32,  // f32 -> i32
       2,
       kLocalI32,
       kLocalF64,
       kLocalF64,  // (f64,f64) -> i32
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   EXPECT_EQ(3, result.val->signatures.size());
   if (result.val->signatures.size() == 3) {
     EXPECT_EQ(0, result.val->signatures[0]->return_count());
     EXPECT_EQ(1, result.val->signatures[1]->return_count());
     EXPECT_EQ(1, result.val->signatures[2]->return_count());
 
     EXPECT_EQ(0, result.val->signatures[0]->parameter_count());
     EXPECT_EQ(1, result.val->signatures[1]->parameter_count());
     EXPECT_EQ(2, result.val->signatures[2]->parameter_count());
   }
@@ skipping 27 matching lines @@
 
 TEST_F(WasmModuleVerifyTest, OneEmptyVoidVoidFunction) {
   const int kCodeStartOffset = 51;
   const int kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE), 1,
       // sig#0 -------------------------------------------------------
       VOID_VOID_SIG,
       // func#0 ------------------------------------------------------
-      SECTION(FUNCTIONS, 19), 1,
+      SECTION(FUNCTIONS, 18), 1,
       kDeclFunctionLocals | kDeclFunctionExport | kDeclFunctionName,
       SIG_INDEX(0),              // signature index
       NAME_LENGTH(2), 'h', 'i',  // name
       U16_LE(1466),              // local int32 count
       U16_LE(1355),              // local int64 count
       U16_LE(1244),              // local float32 count
       U16_LE(1133),              // local float64 count
       1, 0,                      // size
       kExprNop,
   };
 
   {
     // Should decode to exactly one function.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(0, result.val->globals.size());
     EXPECT_EQ(1, result.val->signatures.size());
     EXPECT_EQ(1, result.val->functions.size());
     EXPECT_EQ(0, result.val->data_segments.size());
     EXPECT_EQ(0, result.val->function_table.size());
 
     WasmFunction* function = &result.val->functions.back();
 
     EXPECT_EQ(39, function->name_offset);
     EXPECT_EQ(2, function->name_length);
@@ skipping 12 matching lines @@
   }
 
   EXPECT_OFF_END_FAILURE(data, 16, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneFunctionImported) {
   static const byte data[] = {
       SECTION(SIGNATURES, VOID_VOID_SIG_SIZE), 1,
       // sig#0 -------------------------------------------------------
-      VOID_VOID_SIG, SECTION(FUNCTIONS, 6), 1,
+      VOID_VOID_SIG, SECTION(FUNCTIONS, 4), 1,
       // func#0 ------------------------------------------------------
       kDeclFunctionImport,  // no name, no locals, imported
       SIG_INDEX(0),
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   EXPECT_EQ(1, result.val->functions.size());
   WasmFunction* function = &result.val->functions.back();
 
   EXPECT_EQ(0, function->name_length);
   EXPECT_EQ(0, function->code_start_offset);
   EXPECT_EQ(0, function->code_end_offset);
 
   EXPECT_EQ(0, function->local_i32_count);
   EXPECT_EQ(0, function->local_i64_count);
   EXPECT_EQ(0, function->local_f32_count);
@@ skipping 15 matching lines @@
       0, 0,  // void -> void
       SECTION(FUNCTIONS, 7), 1,
       // func#0 ------------------------------------------------------
       0,        // no name, no locals
       0, 0,     // signature index
       1, 0,     // body size
       kExprNop  // body
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   EXPECT_EQ(1, result.val->functions.size());
   WasmFunction* function = &result.val->functions.back();
 
   EXPECT_EQ(0, function->name_length);
   EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
   EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
   EXPECT_EQ(0, function->local_i32_count);
   EXPECT_EQ(0, function->local_i64_count);
   EXPECT_EQ(0, function->local_f32_count);
@@ skipping 19 matching lines @@
       kDeclFunctionLocals, 0, 0,  // signature index
       1, 2,                       // local int32 count
       3, 4,                       // local int64 count
       5, 6,                       // local float32 count
       7, 8,                       // local float64 count
       1, 0,                       // body size
       kExprNop                    // body
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   EXPECT_EQ(1, result.val->functions.size());
   WasmFunction* function = &result.val->functions.back();
 
   EXPECT_EQ(0, function->name_length);
   EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
   EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
   EXPECT_EQ(513, function->local_i32_count);
   EXPECT_EQ(1027, function->local_i64_count);
   EXPECT_EQ(1541, function->local_f32_count);
   EXPECT_EQ(2055, function->local_f64_count);
 
   EXPECT_FALSE(function->exported);
   EXPECT_FALSE(function->external);
 
   if (result.val) delete result.val;
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneGlobalOneFunctionWithNopBodyOneDataSegment) {
-  static const byte kCodeStartOffset = 75;
+  static const byte kCodeStartOffset = 64;
   static const byte kCodeEndOffset = kCodeStartOffset + 3;
-  static const byte kDataSegmentSourceOffset = kCodeEndOffset + 20;
+  static const byte kDataSegmentSourceOffset = kCodeEndOffset + 31;
 
   static const byte data[] = {
-      SECTION(MEMORY, 3), 28, 28, 1,
       // global#0 --------------------------------------------------
-      SECTION(GLOBALS, 7), 1,
+      SECTION(GLOBALS, 4), 1,
       0,       // name length
       kMemU8,  // memory type
       0,       // exported
       // sig#0 -----------------------------------------------------
       SECTION(SIGNATURES, 3), 1, 0, 0,  // void -> void
       // func#0 ----------------------------------------------------
-      SECTION(FUNCTIONS, 20), 1, kDeclFunctionLocals | kDeclFunctionName, 0,
-      0,            // signature index
-      2, 'h', 'i',  // name
-      1, 2,         // local int32 count
-      3, 4,         // local int64 count
-      5, 6,         // local float32 count
-      7, 8,         // local float64 count
-      3, 0,         // body size
-      kExprNop,     // func#0 body
-      kExprNop,     // func#0 body
-      kExprNop,     // func#0 body
+      SECTION(FUNCTIONS, 20), 1,
+      kDeclFunctionLocals | kDeclFunctionName,  // --
+      SIG_INDEX(0),                             // signature index
+      2, 'h', 'i',                              // name
+      1, 2,                                     // local int32 count
+      3, 4,                                     // local int64 count
+      5, 6,                                     // local float32 count
+      7, 8,                                     // local float64 count
+      3, 0,                                     // body size
+      kExprNop,                                 // func#0 body
+      kExprNop,                                 // func#0 body
+      kExprNop,                                 // func#0 body
+      // memory section --------------------------------------------
+      SECTION(MEMORY, 3), 28, 28, 1,
       // segment#0 -------------------------------------------------
       SECTION(DATA_SEGMENTS, 14), 1,
       U32V_3(0x8b3ae),  // dest addr
       U32V_1(5),        // source size
       0, 1, 2, 3, 4,    // data bytes
       // rest ------------------------------------------------------
       SECTION(END, 0),
   };
 
   {
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(1, result.val->globals.size());
     EXPECT_EQ(1, result.val->functions.size());
     EXPECT_EQ(1, result.val->data_segments.size());
 
     WasmGlobal* global = &result.val->globals.back();
 
     EXPECT_EQ(0, global->name_length);
     EXPECT_EQ(MachineType::Uint8(), global->type);
     EXPECT_EQ(0, global->offset);
     EXPECT_FALSE(global->exported);
 
     WasmFunction* function = &result.val->functions.back();
 
-    EXPECT_EQ(63, function->name_offset);
+    EXPECT_EQ(52, function->name_offset);
     EXPECT_EQ(2, function->name_length);
     EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
     EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
     EXPECT_FALSE(function->exported);
     EXPECT_FALSE(function->external);
 
     WasmDataSegment* segment = &result.val->data_segments.back();
 
     EXPECT_EQ(0x8b3ae, segment->dest_addr);
@@ skipping 18 matching lines @@
       U32V_3(0x9bbaa),  // dest addr
       U32V_1(3),        // source size
       'a',
       'b',
       'c'  // data bytes
   };
 
   {
     EXPECT_VERIFIES(data);
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(0, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(1, result.val->data_segments.size());
 
     WasmDataSegment* segment = &result.val->data_segments.back();
 
     EXPECT_EQ(0x9bbaa, segment->dest_addr);
     EXPECT_EQ(kDataSegmentSourceOffset, segment->source_offset);
     EXPECT_EQ(3, segment->source_size);
     EXPECT_TRUE(segment->init);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 13, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
   const byte kDataSegment0SourceOffset = 39;
   const byte kDataSegment1SourceOffset = 39 + 8;
 
   const byte data[] = {
       SECTION(MEMORY, 3),
       28,
       28,
       1,
-      SECTION(DATA_SEGMENTS, 31),
+      SECTION(DATA_SEGMENTS, 23),
       2,                // segment count
       U32V_3(0x7ffee),  // #0: dest addr
       U32V_1(4),        // source size
       1,
       2,
       3,
       4,                // data bytes
       U32V_3(0x6ddcc),  // #1: dest addr
       U32V_1(10),       // source size
       1,
       2,
       3,
       4,
       5,
       6,
       7,
       8,
       9,
       10  // data bytes
   };
 
   {
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(0, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(2, result.val->data_segments.size());
 
     WasmDataSegment* s0 = &result.val->data_segments[0];
     WasmDataSegment* s1 = &result.val->data_segments[1];
 
     EXPECT_EQ(0x7ffee, s0->dest_addr);
     EXPECT_EQ(kDataSegment0SourceOffset, s0->source_offset);
     EXPECT_EQ(4, s0->source_size);
@@ skipping 15 matching lines @@
 
   for (byte mem_pages = 1; mem_pages < 16; mem_pages++) {
     int mem_size = mem_pages * 0x10000;  // 64k pages.
 
     for (int dest_addr = mem_size - source_size;
          dest_addr < mem_size + source_size; dest_addr++) {
       byte data[] = {SECTION(MEMORY, 3),
                      mem_pages,
                      mem_pages,
                      1,
-                     SECTION(DATA_SEGMENTS, 14),
+                     SECTION(DATA_SEGMENTS, 8),
                      1,
                      U32V_3(dest_addr),
                      U32V_1(source_size),
                      'a',
                      'b',
                      'c'};
 
       if (dest_addr <= (mem_size - source_size)) {
         EXPECT_VERIFIES(data);
       } else {
@@ skipping 10 matching lines @@
 TEST_F(WasmModuleVerifyTest, OneIndirectFunction) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       SECTION(SIGNATURES, 3), 1, 0, 0,  // void -> void
       // func#0 ------------------------------------------------------
       SECTION(FUNCTIONS, 4), 1, FUNCTION(0, 0),
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 2), 1, U32V_1(0)};
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   if (result.ok()) {
     EXPECT_EQ(1, result.val->signatures.size());
     EXPECT_EQ(1, result.val->functions.size());
     EXPECT_EQ(1, result.val->function_table.size());
     EXPECT_EQ(0, result.val->function_table[0]);
   }
   if (result.val) delete result.val;
 }
 
 
@@ skipping 13 matching lines @@
       U32V_1(1),  // --
       U32V_1(2),  // --
       U32V_1(3),  // --
       U32V_1(0),  // --
       U32V_1(1),  // --
       U32V_1(2),  // --
       U32V_1(3),  // --
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   if (result.ok()) {
     EXPECT_EQ(2, result.val->signatures.size());
     EXPECT_EQ(4, result.val->functions.size());
     EXPECT_EQ(8, result.val->function_table.size());
     for (int i = 0; i < 8; i++) {
       EXPECT_EQ(i & 3, result.val->function_table[i]);
     }
   }
   if (result.val) delete result.val;
 }
@@ skipping 160 matching lines @@
       4,                    // locals
       3,       kLocalI32,   // --
       4,       kLocalI64,   // --
       5,       kLocalF32,   // --
       6,       kLocalF64,   // --
       kExprNop              // body
   };
 
   FunctionResult result = DecodeWasmFunction(isolate(), zone(), nullptr, data,
                                              data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
 
   if (result.val && result.ok()) {
     WasmFunction* function = result.val;
     EXPECT_EQ(0, function->sig->parameter_count());
     EXPECT_EQ(0, function->sig->return_count());
     EXPECT_EQ(0, function->name_offset);
     EXPECT_EQ(2, function->code_start_offset);
     EXPECT_EQ(arraysize(data), function->code_end_offset);
     // TODO(titzer): verify encoding of local declarations
     EXPECT_FALSE(function->external);
@@ skipping 94 matching lines @@
   };
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, UnknownSectionSkipped) {
   static const byte data[] = {
       3,  // Section size.
       1,
       '\0',  // Section name: LEB128 1, string '\0'
       0,     // one byte section
-      SECTION(GLOBALS, 7),
+      SECTION(GLOBALS, 4),
       1,
       0,        // name length
       kMemI32,  // memory type
       0,        // exported
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
 
   EXPECT_EQ(1, result.val->globals.size());
   EXPECT_EQ(0, result.val->functions.size());
   EXPECT_EQ(0, result.val->data_segments.size());
 
   WasmGlobal* global = &result.val->globals.back();
 
   EXPECT_EQ(0, global->name_length);
   EXPECT_EQ(MachineType::Int32(), global->type);
   EXPECT_EQ(0, global->offset);
   EXPECT_FALSE(global->exported);
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_empty) {
   static const byte data[] = {SECTION(SIGNATURES, 1), 0,
                               SECTION(IMPORT_TABLE, 1), 0};
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_nosigs) {
   static const byte data[] = {SECTION(IMPORT_TABLE, 1), 0};
-  EXPECT_FAILURE(data);
+  EXPECT_VERIFIES(data);

[JF, 2016/04/19 15:48:47]

Hmm, this is now OK?

[titzer, 2016/04/20 08:51:24]

Yeah. It's OK to have an empty import table without a signatures section, since
we don't explicitly disallow that in the design. (Of course a non-empty
signatures section would fail to validate any signature indexes in there; I've
added another test.)

 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_invalid_sig) {
   static const byte data[] = {
       SECTION(SIGNATURES, 1), 0,   SECTION(IMPORT_TABLE, 6), 1,
       IMPORT_SIG_INDEX(0),          // sig index
       NAME_LENGTH(1),         'm',  // module name
       NAME_LENGTH(1),         'f',  // function name
   };
   EXPECT_FAILURE(data);
@@ skipping 79 matching lines @@
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableOne) {
   static const byte data[] = {
       SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
       1,              // sigs
       VOID_VOID_SIG,  // --
       SECTION(FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
       1,                  // functions
       EMPTY_FUNCTION(0),  // --
-      SECTION(EXPORT_TABLE, 7),
+      SECTION(EXPORT_TABLE, 3),
       1,              // exports
       FUNC_INDEX(0),  // --
       NO_NAME         // --
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableTwo) {
   static const byte data[] = {
       SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
@@ skipping 192 matching lines @@
       NO_LOCAL_NAMES,  // --
       FOO_STRING,
       NO_LOCAL_NAMES,  // --
   };
   EXPECT_VERIFIES(data);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8