[wasm] Add a magic word and a version number to the binary.

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 VOID_VOID_SIG 0, kLocalVoid
 #define INT_INT_SIG 1, kLocalI32, kLocalI32
 
-#define U32(v)                                                                 \
-  static_cast<byte>(v), static_cast<byte>(v >> 8), static_cast<byte>(v >> 16), \
-      static_cast<byte>(v >> 24)
-#define U16(v) static_cast<byte>(v), static_cast<byte>(v >> 8)
-#define U8(v) static_cast<byte>(v)
-
-#define SIG_INDEX(v) U16(v)
-#define FUNC_INDEX(v) U16(v)
-#define NAME_OFFSET(v) U32(v)
-
-#define EMPTY_FUNCTION(sig_index) 0, SIG_INDEX(sig_index), U16(0)
-
-class WasmModuleVerifyTest : public TestWithZone {
- public:
-  ModuleResult DecodeModule(const byte* module_start, const byte* module_end) {
-    return DecodeWasmModule(nullptr, zone(), module_start, module_end, false,
-                            kWasmOrigin);
-  }
-};
-
-
 #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(data)                                          \
-  do {                                                                \
-    ModuleResult result = DecodeModule(data, data + arraysize(data)); \
-    EXPECT_FALSE(result.ok());                                        \
-    if (result.val) delete result.val;                                \
+#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)
 
 struct LocalTypePair {
   uint8_t code;
   LocalType type;
 } kLocalTypes[] = {{kLocalI32, kAstI32},
                    {kLocalI64, kAstI64},
                    {kLocalF32, kAstF32},
                    {kLocalF64, kAstF64}};
 
+class WasmModuleVerifyTest : public TestWithZone {
+ public:
+  ModuleResult DecodeModule(const byte* module_start, const byte* module_end) {
+    // Add the WASM magic and version number automatically.
+    size_t size = static_cast<size_t>(module_end - module_start);
+    byte header[] = {WASM_MODULE_HEADER};
+    size_t total = sizeof(header) + size;
+    auto temp = new byte[total];
+    memcpy(temp, header, sizeof(header));
+    memcpy(temp + sizeof(header), module_start, size);
+    ModuleResult result = DecodeWasmModule(nullptr, zone(), temp, temp + total,
+                                           false, kWasmOrigin);
+    delete[] temp;
+    return result;
+  }
+  ModuleResult DecodeModuleNoHeader(const byte* module_start,
+                                    const byte* module_end) {
+    return DecodeWasmModule(nullptr, zone(), module_start, module_end, false,
+                            kWasmOrigin);
+  }
+};
 
-TEST_F(WasmModuleVerifyTest, DecodeEmpty) {
-  static const byte data[1]{kDeclEnd};
-  {
-    ModuleResult result = DecodeModule(data, data);
-    EXPECT_TRUE(result.ok());
-    if (result.val) delete result.val;
-  }
-  {
-    ModuleResult result = DecodeModule(data, data + 1);
-    EXPECT_TRUE(result.ok());
+TEST_F(WasmModuleVerifyTest, WrongMagic) {
+  for (uint32_t x = 1; x; x <<= 1) {
+    const byte data[] = {U32_LE(kWasmMagic ^ x), U32_LE(kWasmVersion),
+                         kDeclEnd};
+    ModuleResult result = DecodeModuleNoHeader(data, data + sizeof(data));
+    EXPECT_FALSE(result.ok());
     if (result.val) delete result.val;
   }
 }
 
+TEST_F(WasmModuleVerifyTest, WrongVersion) {
+  for (uint32_t x = 1; x; x <<= 1) {
+    const byte data[] = {U32_LE(kWasmMagic), U32_LE(kWasmVersion ^ x),
+                         kDeclEnd};
+    ModuleResult result = DecodeModuleNoHeader(data, data + sizeof(data));
+    EXPECT_FALSE(result.ok());
+    if (result.val) delete result.val;
+  }
+}
+
+TEST_F(WasmModuleVerifyTest, DecodeEmpty) {
+  static const byte data[] = {kDeclEnd};
+  EXPECT_VERIFIES(data);
+}
 
 TEST_F(WasmModuleVerifyTest, OneGlobal) {
   static const byte data[] = {
       kDeclGlobals,
       1,
       NAME_OFFSET(0),
       kMemI32,  // memory type
       0,        // exported
   };
 
   {
     // Should decode to exactly one global.
     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;
   }
 
-  for (size_t size = 1; size < arraysize(data); size++) {
-    // Should fall off end of module bytes.
-    ModuleResult result = DecodeModule(data, data + size);
-    EXPECT_FALSE(result.ok());
-    if (result.val) delete result.val;
-  }
+  EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
   static const byte data[] = {
       kDeclGlobals, 0,  // declare 0 globals
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_TRUE(result.ok());
   if (result.val) delete result.val;
@@ skipping 14 matching lines @@
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, NGlobals) {
   static const byte data[] = {
       NAME_OFFSET(0),  // name offset
       kMemI32,         // memory type
       0,               // exported
   };
-  for (uint32_t i = 0; i < 1000000; i = i * 7 + 1) {
+
+  for (uint32_t i = 0; i < 1000000; i = i * 13 + 1) {
     std::vector<byte> buffer;
     buffer.push_back(kDeclGlobals);
     AppendUint32v(buffer, i);
     for (uint32_t j = 0; j < i; j++) {
-      buffer.insert(buffer.end(), data, data + arraysize(data));
+      buffer.insert(buffer.end(), data, data + sizeof(data));
     }
 
     ModuleResult result = DecodeModule(&buffer[0], &buffer[0] + buffer.size());
     EXPECT_TRUE(result.ok());
     if (result.val) delete result.val;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, GlobalWithInvalidNameOffset) {
@@ skipping 51 matching lines @@
     EXPECT_FALSE(g0->exported);
 
     EXPECT_EQ(0, g1->name_offset);
     EXPECT_EQ(MachineType::Float64(), g1->type);
     EXPECT_EQ(0, g1->offset);
     EXPECT_TRUE(g1->exported);
 
     if (result.val) delete result.val;
   }
 
-  for (size_t size = 1; size < arraysize(data); size++) {
-    // Should fall off end of module bytes.
-    ModuleResult result = DecodeModule(data, data + size);
-    EXPECT_FALSE(result.ok());
-    if (result.val) delete result.val;
-  }
+  EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneSignature) {
   {
     static const byte data[] = {kDeclSignatures, 1, VOID_VOID_SIG};
     EXPECT_VERIFIES(data);
   }
 
   {
@@ skipping 25 matching lines @@
     EXPECT_EQ(0, result.val->signatures->at(0)->return_count());
     EXPECT_EQ(1, result.val->signatures->at(1)->return_count());
     EXPECT_EQ(1, result.val->signatures->at(2)->return_count());
 
     EXPECT_EQ(0, result.val->signatures->at(0)->parameter_count());
     EXPECT_EQ(1, result.val->signatures->at(1)->parameter_count());
     EXPECT_EQ(2, result.val->signatures->at(2)->parameter_count());
   }
   if (result.val) delete result.val;
 
-  for (size_t size = 1; size < arraysize(data); size++) {
-    ModuleResult result = DecodeModule(data, data + size);
-    // Should fall off the end of module bytes.
-    EXPECT_FALSE(result.ok());
-    if (result.val) delete result.val;
-  }
+  EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, FunctionWithoutSig) {
   static const byte data[] = {
       kDeclFunctions, 1,
       // func#0 ------------------------------------------------------
       SIG_INDEX(0),    // signature index
       NAME_OFFSET(0),  // name offset
-      U32(0),          // code start offset
-      U32(0),          // code end offset
-      U16(899),        // local int32 count
-      U16(799),        // local int64 count
-      U16(699),        // local float32 count
-      U16(599),        // local float64 count
+      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
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_FALSE(result.ok());
   if (result.val) delete result.val;
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneEmptyVoidVoidFunction) {
-  const int kCodeStartOffset = 23;
+  const int kCodeStartOffset = 31;
   const int kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
       VOID_VOID_SIG,
       // func#0 ------------------------------------------------------
       kDeclFunctions, 1,
       kDeclFunctionLocals | kDeclFunctionExport | kDeclFunctionName,
       SIG_INDEX(0),    // signature index
       NAME_OFFSET(9),  // name offset
-      U16(1466),       // local int32 count
-      U16(1355),       // local int64 count
-      U16(1244),       // local float32 count
-      U16(1133),       // local float64 count
+      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_EQ(0, result.val->globals->size());
     EXPECT_EQ(1, result.val->signatures->size());
@@ skipping 11 matching lines @@
     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;
   }
 
-  for (size_t size = 5; size < arraysize(data); size++) {
-    // Should fall off end of module bytes.
-    ModuleResult result = DecodeModule(data, data + size);
-    EXPECT_FALSE(result.ok());
-    if (result.val) delete result.val;
-  }
+  EXPECT_OFF_END_FAILURE(data, 5, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneFunctionImported) {
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
       VOID_VOID_SIG, kDeclFunctions, 1,
       // func#0 ------------------------------------------------------
       kDeclFunctionImport,  // no name, no locals, imported
@@ skipping 15 matching lines @@
   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 = 11;
+  static const byte kCodeStartOffset = 19;
   static const byte kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
       0, 0,  // void -> void
       kDeclFunctions, 1,
       // func#0 ------------------------------------------------------
       0,        // no name, no locals
       0, 0,     // signature index
@@ skipping 16 matching lines @@
   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 = 19;
+  static const byte kCodeStartOffset = 27;
   static const byte kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
       0, 0,  // void -> void
       kDeclFunctions, 1,
       // func#0 ------------------------------------------------------
       kDeclFunctionLocals, 0, 0,  // signature index
       1, 2,                       // local int32 count
@@ skipping 21 matching lines @@
   EXPECT_FALSE(function->exported);
   EXPECT_FALSE(function->external);
 
   if (result.val) delete result.val;
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneGlobalOneFunctionWithNopBodyOneDataSegment) {
   static const byte kDeclMemorySize = 4;
   static const byte kCodeStartOffset =
-      2 + kDeclMemorySize + kDeclGlobalSize + 4 + 2 + 17;
+      8 + 2 + kDeclMemorySize + kDeclGlobalSize + 4 + 2 + 17;
   static const byte kCodeEndOffset = kCodeStartOffset + 3;
 
   static const byte data[] = {
       kDeclMemory, 28, 28, 1,
       // global#0 --------------------------------------------------
       kDeclGlobals, 1, 0, 0, 0, 0,  // name offset
       kMemU8,                       // memory type
       0,                            // exported
       // sig#0 -----------------------------------------------------
       kDeclSignatures, 1, 0, 0,  // void -> void
@@ skipping 75 matching lines @@
     WasmDataSegment* segment = &result.val->data_segments->back();
 
     EXPECT_EQ(0x9bbaa, segment->dest_addr);
     EXPECT_EQ(11, segment->source_offset);
     EXPECT_EQ(3, segment->source_size);
     EXPECT_TRUE(segment->init);
 
     if (result.val) delete result.val;
   }
 
-  for (size_t size = 5; size < arraysize(data); size++) {
-    // Should fall off end of module bytes.
-    ModuleResult result = DecodeModule(data, data + size);
-    EXPECT_FALSE(result.ok());
-    if (result.val) delete result.val;
-  }
+  EXPECT_OFF_END_FAILURE(data, 5, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
   const byte data[] = {
       kDeclMemory, 28,   28,   1, kDeclDataSegments, 2, 0xee, 0xff, 0x07,
       0,  // dest addr
       9,           0,    0,
       0,  // #0: source offset
       4,           0,    0,
@@ skipping 24 matching lines @@
     EXPECT_FALSE(s0->init);
 
     EXPECT_EQ(0x6ddcc, s1->dest_addr);
     EXPECT_EQ(6, s1->source_offset);
     EXPECT_EQ(10, s1->source_size);
     EXPECT_TRUE(s1->init);
 
     if (result.val) delete result.val;
   }
 
-  for (size_t size = 5; size < arraysize(data); size++) {
-    // Should fall off end of module bytes.
-    ModuleResult result = DecodeModule(data, data + size);
-    EXPECT_FALSE(result.ok());
-    if (result.val) delete result.val;
-  }
+  EXPECT_OFF_END_FAILURE(data, 5, sizeof(data));
 }
 
 
 TEST_F(WasmModuleVerifyTest, DataSegmentWithInvalidSource) {
   const int dest_addr = 0x100;
   const byte mem_size_log2 = 15;
+  const int kHeaderSize = 8;
   const int kDataSize = 19;
+  const int kTotalSize = kHeaderSize + kDataSize;
 
   for (int source_offset = 0; source_offset < 5 + kDataSize; source_offset++) {
     for (int source_size = -1; source_size < 5 + kDataSize; source_size += 3) {
       byte data[] = {
           kDeclMemory,
           mem_size_log2,
           mem_size_log2,
           1,
           kDeclDataSegments,
           1,
-          U32(dest_addr),
-          U32(source_offset),
-          U32(source_size),
+          U32_LE(dest_addr),
+          U32_LE(source_offset),
+          U32_LE(source_size),
           1,  // init
       };
 
       STATIC_ASSERT(kDataSize == arraysize(data));
 
-      if (source_offset < kDataSize && source_size >= 0 &&
-          (source_offset + source_size) <= kDataSize) {
+      if (source_offset < kTotalSize && source_size >= 0 &&
+          (source_offset + source_size) <= kTotalSize) {
         EXPECT_VERIFIES(data);
       } else {
         EXPECT_FAILURE(data);
       }
     }
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, DataSegmentWithInvalidDest) {
   const int source_size = 3;
   const int source_offset = 11;
 
   for (byte mem_size_log2 = 12; mem_size_log2 < 20; mem_size_log2++) {
     int mem_size = 1 << mem_size_log2;
 
     for (int dest_addr = mem_size - source_size;
          dest_addr < mem_size + source_size; dest_addr++) {
       byte data[] = {
           kDeclMemory,
           mem_size_log2,
           mem_size_log2,
           1,
           kDeclDataSegments,
           1,
-          U32(dest_addr),
-          U32(source_offset),
-          U32(source_size),
+          U32_LE(dest_addr),
+          U32_LE(source_offset),
+          U32_LE(source_size),
           1,  // init
       };
 
       if (dest_addr <= (mem_size - source_size)) {
         EXPECT_VERIFIES(data);
       } else {
         EXPECT_FAILURE(data);
       }
     }
   }
@@ skipping 347 matching lines @@
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_off_end) {
   static const byte data[] = {
       kDeclSignatures, 1, VOID_VOID_SIG, kDeclImportTable, 1,
       SIG_INDEX(0),    // sig index
       NAME_OFFSET(1),  // module name
       NAME_OFFSET(1),  // function name
   };
 
-  for (size_t length = 5; length < sizeof(data); length++) {
-    ModuleResult result = DecodeModule(data, data + length);
-    EXPECT_FALSE(result.ok());
-    if (result.val) delete result.val;
-  }
+  EXPECT_OFF_END_FAILURE(data, 5, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_empty) {
   static const byte data[] = {kDeclSignatures,  0, kDeclFunctions, 0,
                               kDeclExportTable, 0};
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_NoFunctions1) {
   static const byte data[] = {kDeclSignatures, 0, kDeclExportTable, 0};
@@ skipping 88 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