Fix memory leaks and compiler incompatibilities in wasm unittests.

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-opcodes.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 class WasmModuleVerifyTest : public TestWithZone {
  public:
   ModuleResult DecodeModule(const byte* module_start, const byte* module_end) {
     return DecodeWasmModule(nullptr, zone(), module_start, module_end, false,
                             false);
   }
 };
 
 
 #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;                                \
   } while (false)
 
 
 struct LocalTypePair {
   uint8_t code;
   LocalType type;
 } kLocalTypes[] = {{kLocalI32, kAstI32},
                    {kLocalI64, kAstI64},
                    {kLocalF32, kAstF32},
                    {kLocalF64, kAstF64}};
 
 
 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());
+    if (result.val) delete result.val;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneGlobal) {
   const byte data[] = {
       kDeclGlobals,
       1,
       0,
       0,
       0,
       0,        // name offset
       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_EQ(false, global->exported);
+    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;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
   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;
 }
 
 
 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));
       val = next;
     } else {
       buffer.push_back(static_cast<byte>(out));
       break;
     }
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, NGlobals) {
   const byte data[] = {
       0,       0, 0, 0,  // name offset
       kMemI32,           // memory type
       0,                 // exported
   };
   for (uint32_t i = 0; i < 1000000; i = i * 7 + 1) {
     std::vector<byte> buffer;
     buffer.push_back(kDeclGlobals);
     AppendUint32v(buffer, i);
-    for (int j = 0; j < i; j++) {
+    for (int j = 0; j < static_cast<int>(i); j++) {

[ahaas, 2015/12/17 10:59:43]

nit: Why do you use the type "int" here? j is not used here, so it could have
type uint32_t and you can ignore the type cast.

[bradn, 2015/12/17 11:03:17]

Ah, good point. Mechanical blinders on.
Done.

       buffer.insert(buffer.end(), data, data + arraysize(data));
     }
 
     ModuleResult result = DecodeModule(&buffer[0], &buffer[0] + buffer.size());
     EXPECT_TRUE(result.ok());
+    if (result.val) delete result.val;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, GlobalWithInvalidNameOffset) {
   const byte data[] = {
       kDeclGlobals,
       1,  // declare one global
       0,
       3,
@@ skipping 48 matching lines @@
     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->at(0);
     WasmGlobal* g1 = &result.val->globals->at(1);
 
     EXPECT_EQ(0, g0->name_offset);
     EXPECT_EQ(MachineType::Float32(), g0->type);
     EXPECT_EQ(0, g0->offset);
-    EXPECT_EQ(false, g0->exported);
+    EXPECT_FALSE(g0->exported);
 
     EXPECT_EQ(0, g1->name_offset);
     EXPECT_EQ(MachineType::Float64(), g1->type);
     EXPECT_EQ(0, g1->offset);
-    EXPECT_EQ(true, g1->exported);
+    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;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneSignature) {
   static const byte data[] = {
       kDeclSignatures, 1, 0, kLocalVoid  // void -> void
   };
   EXPECT_VERIFIES(data);
 }
@@ skipping 19 matching lines @@
   EXPECT_EQ(3, result.val->signatures->size());
   if (result.val->signatures->size() == 3) {
     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;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, FunctionWithoutSig) {
   static const byte data[] = {
       kDeclFunctions, 1,
       // func#0 ------------------------------------------------------
       0, 0,        // signature index
       0, 0, 0, 0,  // name offset
       0, 0, 0, 0,  // code start offset
       0, 0, 0, 0,  // code end offset
       1, 2,        // local int32 count
       3, 4,        // local int64 count
       5, 6,        // local float32 count
       7, 8,        // 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 kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
@@ skipping 25 matching lines @@
 
     EXPECT_EQ(9, function->name_offset);
     EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
     EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
     EXPECT_EQ(523, function->local_int32_count);
     EXPECT_EQ(1037, function->local_int64_count);
     EXPECT_EQ(1551, function->local_float32_count);
     EXPECT_EQ(2065, function->local_float64_count);
 
-    EXPECT_EQ(true, function->exported);
-    EXPECT_EQ(false, function->external);
+    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;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneFunctionImported) {
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
       0, 0,  // void -> void
       kDeclFunctions, 1,
       // func#0 ------------------------------------------------------
       kDeclFunctionImport,  // no name, no locals, imported
       0, 0,                 // signature index
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_TRUE(result.ok());
   EXPECT_EQ(1, result.val->functions->size());
   WasmFunction* function = &result.val->functions->back();
 
   EXPECT_EQ(0, function->name_offset);
   EXPECT_EQ(0, function->code_start_offset);
   EXPECT_EQ(0, function->code_end_offset);
 
   EXPECT_EQ(0, function->local_int32_count);
   EXPECT_EQ(0, function->local_int64_count);
   EXPECT_EQ(0, function->local_float32_count);
   EXPECT_EQ(0, function->local_float64_count);
 
-  EXPECT_EQ(false, function->exported);
-  EXPECT_EQ(true, function->external);
+  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 kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
@@ skipping 13 matching lines @@
 
   EXPECT_EQ(0, function->name_offset);
   EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
   EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
   EXPECT_EQ(0, function->local_int32_count);
   EXPECT_EQ(0, function->local_int64_count);
   EXPECT_EQ(0, function->local_float32_count);
   EXPECT_EQ(0, function->local_float64_count);
 
-  EXPECT_EQ(false, function->exported);
-  EXPECT_EQ(false, function->external);
+  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 kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
       kDeclSignatures, 1,
       // sig#0 -------------------------------------------------------
@@ skipping 16 matching lines @@
 
   EXPECT_EQ(0, function->name_offset);
   EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
   EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
   EXPECT_EQ(513, function->local_int32_count);
   EXPECT_EQ(1027, function->local_int64_count);
   EXPECT_EQ(1541, function->local_float32_count);
   EXPECT_EQ(2055, function->local_float64_count);
 
-  EXPECT_EQ(false, function->exported);
-  EXPECT_EQ(false, function->external);
+  EXPECT_FALSE(function->exported);
+  EXPECT_FALSE(function->external);
+
+  if (result.val) delete result.val;
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneGlobalOneFunctionWithNopBodyOneDataSegment) {
   static const byte kCodeStartOffset = 2 + kDeclGlobalSize + 4 + 2 + 17;
   static const byte kCodeEndOffset = kCodeStartOffset + 3;
 
   static const byte data[] = {
       // global#0 --------------------------------------------------
       kDeclGlobals, 1, 0, 0, 0, 0,  // name offset
@@ skipping 27 matching lines @@
     EXPECT_TRUE(result.ok());
     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_offset);
     EXPECT_EQ(MachineType::Uint8(), global->type);
     EXPECT_EQ(0, global->offset);
-    EXPECT_EQ(false, global->exported);
+    EXPECT_FALSE(global->exported);
 
     WasmFunction* function = &result.val->functions->back();
 
     EXPECT_EQ(9, function->name_offset);
     EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
     EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
-    EXPECT_EQ(false, function->exported);
-    EXPECT_EQ(false, function->external);
+    EXPECT_FALSE(function->exported);
+    EXPECT_FALSE(function->external);
 
     WasmDataSegment* segment = &result.val->data_segments->back();
 
     EXPECT_EQ(0x8b3ae, segment->dest_addr);
     EXPECT_EQ(15, segment->source_offset);
     EXPECT_EQ(5, segment->source_size);
-    EXPECT_EQ(true, segment->init);
+    EXPECT_TRUE(segment->init);
+
+    if (result.val) delete result.val;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, OneDataSegment) {
   const byte data[] = {
       kDeclDataSegments,
       1,
       0xaa,
       0xbb,
@@ skipping 15 matching lines @@
     EXPECT_TRUE(result.ok());
     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(11, segment->source_offset);
     EXPECT_EQ(3, segment->source_size);
-    EXPECT_EQ(true, segment->init);
+    EXPECT_TRUE(segment->init);
+
+    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;
   }
 }
 
 
 TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
   const byte data[] = {
       kDeclDataSegments,
       2,
       0xee,
       0xff,
@@ skipping 29 matching lines @@
     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->at(0);
     WasmDataSegment* s1 = &result.val->data_segments->at(1);
 
     EXPECT_EQ(0x7ffee, s0->dest_addr);
     EXPECT_EQ(9, s0->source_offset);
     EXPECT_EQ(4, s0->source_size);
-    EXPECT_EQ(false, s0->init);
+    EXPECT_FALSE(s0->init);
 
     EXPECT_EQ(0x6ddcc, s1->dest_addr);
     EXPECT_EQ(6, s1->source_offset);
     EXPECT_EQ(10, s1->source_size);
-    EXPECT_EQ(true, s1->init);
+    EXPECT_TRUE(s1->init);
+
+    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;
   }
 }
 
 
 // To make below tests for indirect calls much shorter.
 #define FUNCTION(sig_index, external)                \
   kDeclFunctionImport, static_cast<byte>(sig_index), \
       static_cast<byte>(sig_index >> 8)
 
 
 TEST_F(WasmModuleVerifyTest, OneIndirectFunction) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       kDeclSignatures, 1, 0, 0,  // void -> void
       // func#0 ------------------------------------------------------
       kDeclFunctions, 1, FUNCTION(0, 0),
       // indirect table ----------------------------------------------
       kDeclFunctionTable, 1, 0, 0};
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_TRUE(result.ok());
   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->at(0));
   }
+  if (result.val) delete result.val;
 }
 
 
 TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       kDeclSignatures, 2, 0, 0,  // void -> void
       0, kLocalI32,              // void -> i32
       // func#0 ------------------------------------------------------
       kDeclFunctions, 4, FUNCTION(0, 1), FUNCTION(1, 1), FUNCTION(0, 1),
       FUNCTION(1, 1),
       // indirect table ----------------------------------------------
       kDeclFunctionTable, 8, 0, 0, 1, 0, 2, 0, 3, 0, 0, 0, 1, 0, 2, 0, 3, 0,
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
   EXPECT_TRUE(result.ok());
   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->at(i));
     }
   }
+  if (result.val) delete result.val;
 }
 
 
 TEST_F(WasmModuleVerifyTest, IndirectFunctionNoFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       kDeclSignatures, 1, 0, 0,  // void -> void
       // indirect table ----------------------------------------------
       kDeclFunctionTable, 1, 0, 0,
   };
@@ skipping 167 matching lines @@
     EXPECT_EQ(0, function->name_offset);
     EXPECT_EQ(arraysize(data) - 1, function->code_start_offset);
     EXPECT_EQ(arraysize(data), function->code_end_offset);
     EXPECT_EQ(3, function->local_int32_count);
     EXPECT_EQ(4, function->local_int64_count);
     EXPECT_EQ(5, function->local_float32_count);
     EXPECT_EQ(6, function->local_float64_count);
     EXPECT_FALSE(function->external);
     EXPECT_FALSE(function->exported);
   }
+
+  if (result.val) delete result.val;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8