WebAssembly: skip unknown sections, add names

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"
 
@@ skipping 914 matching lines @@
     EXPECT_EQ(4, function->local_i64_count);
     EXPECT_EQ(5, function->local_f32_count);
     EXPECT_EQ(6, function->local_f64_count);
     EXPECT_FALSE(function->external);
     EXPECT_FALSE(function->exported);
   }
 
   if (result.val) delete result.val;
 }
 
-
-TEST_F(WasmModuleVerifyTest, WLLSectionNoLen) {
+TEST_F(WasmModuleVerifyTest, UnknownSectionNoLen) {
   const byte data[] = {
-      kDeclWLL,  // section without length.
+      kMaxModuleSectionCode,  // unknown section without length.
   };
   EXPECT_FAILURE(data);
 }
 
-
-TEST_F(WasmModuleVerifyTest, WLLSectionEmpty) {
-  static const byte data[] = {
-      kDeclWLL, 0,  // empty section
-  };
-  ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
-  if (result.val) delete result.val;
+TEST_F(WasmModuleVerifyTest, UnknownSectionEmpty) {
+  for (int i = 0; i < 255 - kMaxModuleSectionCode; ++i) {
+    const byte data[] = {
+        byte(kMaxModuleSectionCode + i), 0,  // empty unknown section
+    };
+    ModuleResult result = DecodeModule(data, data + arraysize(data));
+    EXPECT_TRUE(result.ok());
+    if (result.val) delete result.val;
+  }
 }
 
-
-TEST_F(WasmModuleVerifyTest, WLLSectionOne) {
+TEST_F(WasmModuleVerifyTest, UnknownSectionOne) {
   static const byte data[] = {
-      kDeclWLL,
+      kMaxModuleSectionCode,
       1,  // LEB128 1
       0,  // one byte section
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_TRUE(result.ok());
   if (result.val) delete result.val;
 }
 
-
-TEST_F(WasmModuleVerifyTest, WLLSectionTen) {
+TEST_F(WasmModuleVerifyTest, UnknownSectionTen) {
   static const byte data[] = {
-      kDeclWLL,
-      10,                                    // LEB128 10
-      1,        2, 3, 4, 5, 6, 7, 8, 9, 10,  // 10 byte section
+      kMaxModuleSectionCode,
+      10,  // LEB128 10
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,  // 10 byte section
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_TRUE(result.ok());
   if (result.val) delete result.val;
 }
 
-
-TEST_F(WasmModuleVerifyTest, WLLSectionOverflow) {
+TEST_F(WasmModuleVerifyTest, UnknownSectionOverflow) {
   static const byte data[] = {
-      kDeclWLL,
-      11,                                    // LEB128 11
-      1,        2, 3, 4, 5, 6, 7, 8, 9, 10,  // 10 byte section
+      kMaxModuleSectionCode,
+      11,  // LEB128 11
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,  // 10 byte section
   };
   EXPECT_FAILURE(data);
 }
 
-
-TEST_F(WasmModuleVerifyTest, WLLSectionUnderflow) {
+TEST_F(WasmModuleVerifyTest, UnknownSectionUnderflow) {
   static const byte data[] = {
-      kDeclWLL, 0xff, 0xff, 0xff, 0xff, 0x0f,  // LEB128 0xffffffff
-      1,        2,    3,    4,                 // 4 byte section
+      kMaxModuleSectionCode,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0x0f,  // LEB128 0xffffffff
+      1,
+      2,
+      3,
+      4,  // 4 byte section
   };
   EXPECT_FAILURE(data);
 }
 
-
-TEST_F(WasmModuleVerifyTest, WLLSectionLoop) {
+TEST_F(WasmModuleVerifyTest, UnknownSectionLoop) {
   // Would infinite loop decoding if wrapping and allowed.
   static const byte data[] = {
-      kDeclWLL, 0xfa, 0xff, 0xff, 0xff, 0x0f,  // LEB128 0xfffffffa
-      1,        2,    3,    4,                 // 4 byte section
+      kMaxModuleSectionCode,
+      0xfa,
+      0xff,
+      0xff,
+      0xff,
+      0x0f,  // LEB128 0xfffffffa
+      1,
+      2,
+      3,
+      4,  // 4 byte section
   };
   EXPECT_FAILURE(data);
 }
 
+TEST_F(WasmModuleVerifyTest, UnknownSectionSkipped) {
+  static const byte data[] = {
+      kMaxModuleSectionCode,
+      1,  // LEB128 1
+      0,  // one byte section
+      kDeclGlobals,
+      1,
+      0,
+      0,
+      0,
+      0,        // name offset
+      kMemI32,  // memory type
+      0,        // exported
+  };
+  ModuleResult result = DecodeModule(data, data + arraysize(data));
+  EXPECT_TRUE(result.ok());
+
+  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_offset);
+  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[] = {kDeclSignatures, 0, kDeclImportTable, 0};
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_nosigs) {
   static const byte data[] = {kDeclImportTable, 0};
   EXPECT_FAILURE(data);
 }
 
@@ skipping 131 matching lines @@
   for (int length = 13; length < sizeof(data); length++) {
     ModuleResult result = DecodeModule(data, data + length);
     EXPECT_FALSE(result.ok());
     if (result.val) delete result.val;
   }
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8