[wasm] Refactor decoding of local declarations and make more robust.

test/unittests/wasm/ast-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/v8.h"
 
 #include "test/cctest/wasm/test-signatures.h"
 
@@ skipping 2179 matching lines @@
   EXPECT_ARITY(1, kExprF64SConvertI32);
   EXPECT_ARITY(1, kExprF64UConvertI32);
   EXPECT_ARITY(1, kExprF64SConvertI64);
   EXPECT_ARITY(1, kExprF64UConvertI64);
   EXPECT_ARITY(1, kExprF64ConvertF32);
   EXPECT_ARITY(1, kExprF64ReinterpretI64);
   EXPECT_ARITY(1, kExprI32ReinterpretF32);
   EXPECT_ARITY(1, kExprI64ReinterpretF64);
 }
 
-typedef std::vector<LocalType>* LocalTypeMap;
+typedef ZoneVector<LocalType> LocalTypeMap;
 
 class LocalDeclDecoderTest : public TestWithZone {
  public:
+  base::AccountingAllocator allocator;
+
   size_t ExpectRun(LocalTypeMap map, size_t pos, LocalType expected,
                    size_t count) {
     for (size_t i = 0; i < count; i++) {
-      EXPECT_EQ(expected, map->at(pos++));
+      EXPECT_EQ(expected, map[pos++]);
     }
     return pos;
   }
+
+  LocalTypeMap Expand(AstLocalDecls& decls) {
+    ZoneVector<LocalType> map(zone());
+    for (auto p : decls.local_types) {
+      map.insert(map.end(), p.second, p.first);
+    }
+    return map;
+  }
 };
 
+TEST_F(LocalDeclDecoderTest, EmptyLocals) {
+  static const byte data[] = {};
+  AstLocalDecls decls(zone());
+  bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
+  EXPECT_FALSE(result);
+}
+
 TEST_F(LocalDeclDecoderTest, NoLocals) {
   static const byte data[] = {0};
-  base::AccountingAllocator allocator;
-  LocalTypeMap map =
-      DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
-  EXPECT_EQ(0, map->size());
-  if (map) delete map;
+  AstLocalDecls decls(zone());
+  bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
+  EXPECT_TRUE(result);
+  EXPECT_EQ(0, decls.total_local_count);
 }
 
 TEST_F(LocalDeclDecoderTest, OneLocal) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalType type = kLocalTypes[i];
     const byte data[] = {
         1, 1, static_cast<byte>(WasmOpcodes::LocalTypeCodeFor(type))};
-    base::AccountingAllocator allocator;
-    LocalTypeMap map =
-        DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
-    EXPECT_EQ(1, map->size());
-    EXPECT_EQ(type, map->at(0));
-    if (map) delete map;
+    AstLocalDecls decls(zone());
+    bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
+    EXPECT_TRUE(result);
+    EXPECT_EQ(1, decls.total_local_count);
+
+    LocalTypeMap map = Expand(decls);
+    EXPECT_EQ(1, map.size());
+    EXPECT_EQ(type, map.at(0));

[ahaas, 2016/04/05 17:04:30]

Wouldn't map[0] also work here?

[titzer, 2016/04/05 17:14:23]

Done.

   }
 }
 
 TEST_F(LocalDeclDecoderTest, FiveLocals) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalType type = kLocalTypes[i];
     const byte data[] = {
         1, 5, static_cast<byte>(WasmOpcodes::LocalTypeCodeFor(type))};
-    base::AccountingAllocator allocator;
-    LocalTypeMap map =
-        DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
-    EXPECT_EQ(5, map->size());
+    AstLocalDecls decls(zone());
+    bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
+    EXPECT_TRUE(result);
+    EXPECT_EQ(sizeof(data), decls.decls_encoded_size);
+    EXPECT_EQ(5, decls.total_local_count);
+
+    LocalTypeMap map = Expand(decls);
+    EXPECT_EQ(5, map.size());
     ExpectRun(map, 0, type, 5);
-    if (map) delete map;
   }
 }
 
 TEST_F(LocalDeclDecoderTest, MixedLocals) {
   for (byte a = 0; a < 3; a++) {
     for (byte b = 0; b < 3; b++) {
       for (byte c = 0; c < 3; c++) {
         for (byte d = 0; d < 3; d++) {
           const byte data[] = {4, a,         kLocalI32, b,        kLocalI64,
                                c, kLocalF32, d,         kLocalF64};
-          base::AccountingAllocator allocator;
-          LocalTypeMap map =
-              DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
-          EXPECT_EQ(a + b + c + d, map->size());
+          AstLocalDecls decls(zone());
+          bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
+          EXPECT_TRUE(result);
+          EXPECT_EQ(sizeof(data), decls.decls_encoded_size);
+          EXPECT_EQ(a + b + c + d, decls.total_local_count);
+
+          LocalTypeMap map = Expand(decls);
+          EXPECT_EQ(a + b + c + d, map.size());
 
           size_t pos = 0;
           pos = ExpectRun(map, pos, kAstI32, a);
           pos = ExpectRun(map, pos, kAstI64, b);
           pos = ExpectRun(map, pos, kAstF32, c);
           pos = ExpectRun(map, pos, kAstF64, d);
-
-          if (map) delete map;
         }
       }
     }
   }
 }
 
 TEST_F(LocalDeclDecoderTest, UseEncoder) {
   const byte* data = nullptr;
   const byte* end = nullptr;
   LocalDeclEncoder local_decls;
 
   local_decls.AddLocals(5, kAstF32);
   local_decls.AddLocals(1337, kAstI32);
   local_decls.AddLocals(212, kAstI64);
   local_decls.Prepend(&data, &end);
 
-  base::AccountingAllocator allocator;
-  LocalTypeMap map = DecodeLocalDeclsForTesting(&allocator, data, end);
+  AstLocalDecls decls(zone());
+  bool result = DecodeLocalDecls(decls, data, end);
+  EXPECT_TRUE(result);
+  EXPECT_EQ(5 + 1337 + 212, decls.total_local_count);
+
+  LocalTypeMap map = Expand(decls);
   size_t pos = 0;
   pos = ExpectRun(map, pos, kAstF32, 5);
   pos = ExpectRun(map, pos, kAstI32, 1337);
   pos = ExpectRun(map, pos, kAstI64, 212);
-
-  if (map) delete map;
   delete[] data;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8