[wasm] Remove the use of the "external" bit on OldFunctions section.

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 SIZEOF_EMPTY_FUNCTION ((size_t)5)
 #define EMPTY_BODY 0
 #define SIZEOF_EMPTY_BODY ((size_t)1)
 #define NOP_BODY 2, 0, kExprNop
 #define SIZEOF_NOP_BODY ((size_t)3)
 
 #define SIG_ENTRY_i_i SIG_ENTRY_x_x(kLocalI32, kLocalI32)
 
 #define UNKNOWN_EMPTY_SECTION_NAME 1, '\0'
 #define UNKNOWN_SECTION_NAME 4, 'l', 'u', 'l', 'z'
 
@@ skipping 300 matching lines @@
       // func#0 ------------------------------------------------------
       SIG_INDEX(0),  // signature index
       NO_NAME,       // name length
       U32_LE(0),     // code start offset
       U32_LE(0),     // code end offset
       U16_LE(899),   // local int32 count
       U16_LE(799),   // local int64 count
       U16_LE(699),   // local float32 count
       U16_LE(599),   // local float64 count
       0,             // exported
-      1              // external
+      0              // external
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_FALSE(result.ok());
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, OneEmptyVoidVoidFunction) {
   const int kCodeStartOffset = 49;
   const int kCodeEndOffset = kCodeStartOffset + 1;
@@ skipping 30 matching lines @@
     EXPECT_EQ(2, function->name_length);
     EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
     EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
     EXPECT_EQ(1466, function->local_i32_count);
     EXPECT_EQ(1355, function->local_i64_count);
     EXPECT_EQ(1244, function->local_f32_count);
     EXPECT_EQ(1133, function->local_f64_count);
 
     EXPECT_TRUE(function->exported);
-    EXPECT_FALSE(function->external);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 16, sizeof(data));
 }
 
-TEST_F(WasmModuleVerifyTest, OneFunctionImported) {
-  static const byte data[] = {
-      // signatures
-      SIGNATURES_SECTION_VOID_VOID,
-      // functions
-      SECTION(OLD_FUNCTIONS, 4), 1,
-      // func#0 ------------------------------------------------------
-      kDeclFunctionImport,  // no name, no locals, imported
-      SIG_INDEX(0),
-  };
-
-  ModuleResult result = DecodeModule(data, data + arraysize(data));
-  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);
-  EXPECT_EQ(0, function->local_f64_count);
-
-  EXPECT_FALSE(function->exported);
-  EXPECT_TRUE(function->external);
-
-  if (result.val) delete result.val;
-}
-
 TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody) {
   static const byte kCodeStartOffset = 38;
   static const byte kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       SIGNATURES_SECTION_VOID_VOID,  // --
       SECTION(OLD_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_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);
   EXPECT_EQ(0, function->local_f64_count);
 
   EXPECT_FALSE(function->exported);
-  EXPECT_FALSE(function->external);
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody_WithLocals) {
   static const byte kCodeStartOffset = 46;
   static const byte kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       SIGNATURES_SECTION_VOID_VOID,  // --
@@ skipping 16 matching lines @@
   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 kNameOffset = 49;
   static const byte kCodeStartOffset = 61;
   static const byte kCodeEndOffset = kCodeStartOffset + 3;
   static const byte kDataSegmentSourceOffset = kCodeEndOffset + 22;
 
@@ skipping 44 matching lines @@
     EXPECT_FALSE(global->exported);
 
     WasmFunction* function = &result.val->functions.back();
 
     EXPECT_EQ(kNameOffset, 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);
     EXPECT_EQ(kDataSegmentSourceOffset, segment->source_offset);
     EXPECT_EQ(5, segment->source_size);
     EXPECT_TRUE(segment->init);
 
     if (result.val) delete result.val;
   }
@@ skipping 115 matching lines @@
 
       if (dest_addr <= (mem_size - source_size)) {
         EXPECT_VERIFIES(data);
       } else {
         EXPECT_FAILURE(data);
       }
     }
   }
 }
 
-// To make below tests for indirect calls much shorter.
-#define FUNCTION(sig_index, external) kDeclFunctionImport, SIG_INDEX(sig_index)
-
 TEST_F(WasmModuleVerifyTest, OneIndirectFunction) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       SIGNATURES_SECTION_VOID_VOID,
       // func#0 ------------------------------------------------------
-      SECTION(OLD_FUNCTIONS, 4), 1, FUNCTION(0, 0),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION), 1,  // --
+      EMPTY_FUNCTION(0),
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 2), 1, U32V_1(0)};
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   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;
 }
 
 TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       SECTION(SIGNATURES, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_v_x),
       2,                         // --
       SIG_ENTRY_v_v,             // void -> void
       SIG_ENTRY_v_x(kLocalI32),  // void -> i32
       // func#0 ------------------------------------------------------
-      SECTION(OLD_FUNCTIONS, 13), 4, FUNCTION(0, 1),  // --
-      FUNCTION(1, 1),                                 // --
-      FUNCTION(0, 1),                                 // --
-      FUNCTION(1, 1),                                 // --
+      SECTION(OLD_FUNCTIONS, 1 + 4 * SIZEOF_EMPTY_FUNCTION), 4,  // --
+      EMPTY_FUNCTION(0),                                         // --
+      EMPTY_FUNCTION(1),                                         // --
+      EMPTY_FUNCTION(0),                                         // --
+      EMPTY_FUNCTION(1),                                         // --
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 9), 8,
       U32V_1(0),  // --
       U32V_1(1),  // --
       U32V_1(2),  // --
       U32V_1(3),  // --
       U32V_1(0),  // --
       U32V_1(1),  // --
       U32V_1(2),  // --
       U32V_1(3),  // --
@@ skipping 21 matching lines @@
   };
 
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, IndirectFunctionInvalidIndex) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       SIGNATURES_SECTION_VOID_VOID,
       // functions ---------------------------------------------------
-      SECTION(OLD_FUNCTIONS, 4), 1, FUNCTION(0, 1),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION), 1,  // --
+      EMPTY_FUNCTION(0),
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 3), 1, 1, 0,
   };
 
   EXPECT_FAILURE(data);
 }
 
 class WasmSignatureDecodeTest : public TestWithZone {};
 
 TEST_F(WasmSignatureDecodeTest, Ok_v_v) {
@@ skipping 141 matching lines @@
   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(SIZEOF_SIG_ENTRY_v_v, function->code_start_offset);
     EXPECT_EQ(arraysize(data), function->code_end_offset);
     // TODO(titzer): verify encoding of local declarations
-    EXPECT_FALSE(function->external);
     EXPECT_FALSE(function->exported);
   }
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, SectionWithoutNameLength) {
   const byte data[] = {1};
   EXPECT_FAILURE(data);
 }
@@ skipping 215 matching lines @@
       'f',  // function name
   };
 
   EXPECT_OFF_END_FAILURE(data, 16, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_empty1) {
   static const byte data[] = {
       // signatures
       SIGNATURES_SECTION_VOID_VOID,
-      SECTION(OLD_FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
       1,
       EMPTY_FUNCTION(0),
       SECTION(EXPORT_TABLE, 1),
       0  // --
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_empty2) {
   static const byte data[] = {
@@ skipping 13 matching lines @@
 
 TEST_F(WasmModuleVerifyTest, ExportTable_NoFunctions2) {
   static const byte data[] = {SECTION(EXPORT_TABLE, 1), 0};
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableOne) {
   static const byte data[] = {
       // signatures
       SIGNATURES_SECTION_VOID_VOID,
-      SECTION(OLD_FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
       1,                  // functions
       EMPTY_FUNCTION(0),  // --
       SECTION(EXPORT_TABLE, 3),
       1,              // exports
       FUNC_INDEX(0),  // --
       NO_NAME         // --
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableTwo) {
   static const byte data[] = {
       // signatures
       SIGNATURES_SECTION_VOID_VOID,
-      SECTION(OLD_FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
       1,                  // functions
       EMPTY_FUNCTION(0),  // --
       SECTION(EXPORT_TABLE, 12),
       2,              // exports
       FUNC_INDEX(0),  // --
       NAME_LENGTH(4),
       'n',
       'a',
       'm',
       'e',            // --
       FUNC_INDEX(0),  // --
       NAME_LENGTH(3),
       'n',
       'o',
       'm'  // --
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableThree) {
   static const byte data[] = {
       // signatures
       SIGNATURES_SECTION_VOID_VOID,
-      SECTION(OLD_FUNCTIONS, 1 + 3 * EMPTY_FUNCTION_SIZE),
+      SECTION(OLD_FUNCTIONS, 1 + 3 * SIZEOF_EMPTY_FUNCTION),
       3,                  // functions
       EMPTY_FUNCTION(0),  // --
       EMPTY_FUNCTION(0),  // --
       EMPTY_FUNCTION(0),  // --
       SECTION(EXPORT_TABLE, 10),
       3,              // exports
       FUNC_INDEX(0),  // --
       NAME_LENGTH(1),
       'a',            // --
       FUNC_INDEX(1),  // --
       NAME_LENGTH(1),
       'b',            // --
       FUNC_INDEX(2),  // --
       NAME_LENGTH(1),
       'c'  // --
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableThreeOne) {
   for (int i = 0; i < 6; i++) {
     const byte data[] = {
         // signatures
         SIGNATURES_SECTION_VOID_VOID,
-        SECTION(OLD_FUNCTIONS, 1 + 3 * EMPTY_FUNCTION_SIZE),
+        SECTION(OLD_FUNCTIONS, 1 + 3 * SIZEOF_EMPTY_FUNCTION),
         3,                  // functions
         EMPTY_FUNCTION(0),  // --
         EMPTY_FUNCTION(0),  // --
         EMPTY_FUNCTION(0),  // --
         SECTION(EXPORT_TABLE, 5),
         1,              // exports
         FUNC_INDEX(i),  // --
         NAME_LENGTH(2),
         'e',
         'x',  // --
     };
 
     if (i < 3) {
       EXPECT_VERIFIES(data);
     } else {
       EXPECT_FAILURE(data);
     }
   }
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableOne_off_end) {
   static const byte data[] = {
       // signatures
       SIGNATURES_SECTION_VOID_VOID,
-      SECTION(OLD_FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
       1,                  // functions
       EMPTY_FUNCTION(0),  // --
       SECTION(EXPORT_TABLE, 1 + 6),
       1,              // exports
       FUNC_INDEX(0),  // --
       NO_NAME         // --
   };
 
   for (int length = 33; length < sizeof(data); length++) {
     ModuleResult result = DecodeModule(data, data + length);
@@ skipping 103 matching lines @@
       NO_LOCAL_NAMES,  // --
       FOO_STRING,
       NO_LOCAL_NAMES,  // --
   };
   EXPECT_VERIFIES(data);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8