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

src/wasm/ast-decoder.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 "src/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 394 matching lines @@
     if (ok()) {
       TRACE("wasm-decode ok\n");
     } else {
       TRACE("wasm-error module+%-6d func+%d: %s\n\n", baserel(error_pc_),
             startrel(error_pc_), error_msg_.get());
     }
 
     return toResult(tree);
   }
 
-  std::vector<LocalType>* DecodeLocalDeclsForTesting() {
+  bool DecodeLocalDecls(AstLocalDecls& decls) {
     DecodeLocalDecls();
-    if (failed()) return nullptr;
-    auto result = new std::vector<LocalType>();
-    result->reserve(local_type_vec_.size());
-    for (size_t i = 0; i < local_type_vec_.size(); i++) {
-      result->push_back(local_type_vec_[i]);
+    if (failed()) return false;
+    decls.decls_encoded_size = pc_offset();
+    decls.total_local_count = 0;
+    decls.local_types.reserve(local_type_vec_.size());
+    for (size_t pos = 0; pos < local_type_vec_.size();) {
+      uint32_t count = 0;
+      LocalType type = local_type_vec_[pos];
+      while (pos < local_type_vec_.size() && local_type_vec_[pos] == type) {
+        pos++;
+        count++;
+      }
+      decls.total_local_count += count;
+      decls.local_types.push_back(std::pair<LocalType, uint32_t>(type, count));
     }
-    return result;
+    return true;
   }
 
   BitVector* AnalyzeLoopAssignmentForTesting(const byte* pc,
                                              size_t num_locals) {
     total_locals_ = num_locals;
     local_type_vec_.reserve(num_locals);
     if (num_locals > local_type_vec_.size()) {
       local_type_vec_.insert(local_type_vec_.end(),
                              num_locals - local_type_vec_.size(), kAstI32);
     }
@@ skipping 1185 matching lines @@
       while (arity_stack.back() == 0) {
         arity_stack.pop_back();
         if (arity_stack.empty()) return assigned;  // reached end of loop
         arity_stack.back()--;
       }
     }
     return assigned;
   }
 };
 
-std::vector<LocalType>* DecodeLocalDeclsForTesting(
-    base::AccountingAllocator* allocator, const byte* start, const byte* end) {
-  Zone zone(allocator);
+bool DecodeLocalDecls(AstLocalDecls& decls, const byte* start,
+                      const byte* end) {
+  base::AccountingAllocator allocator;
+  Zone tmp(&allocator);
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
-  SR_WasmDecoder decoder(&zone, nullptr, body);
-  return decoder.DecodeLocalDeclsForTesting();
+  SR_WasmDecoder decoder(&tmp, nullptr, body);
+  return decoder.DecodeLocalDecls(decls);
 }
 
 TreeResult VerifyWasmCode(base::AccountingAllocator* allocator,
                           FunctionBody& body) {
   Zone zone(allocator);
   SR_WasmDecoder decoder(&zone, nullptr, body);
   TreeResult result = decoder.Decode();
   return result;
 }
 
@@ skipping 48 matching lines @@
   SR_WasmDecoder decoder(&zone, nullptr, body);
 
   OFStream os(stdout);
 
   // Print the function signature.
   if (body.sig) {
     os << "// signature: " << *body.sig << std::endl;
   }
 
   // Print the local declarations.
-  std::vector<LocalType>* decls = decoder.DecodeLocalDeclsForTesting();
+  AstLocalDecls decls(&zone);
+  decoder.DecodeLocalDecls(decls);
   const byte* pc = decoder.pc();
   if (body.start != decoder.pc()) {
     printf("// locals:");
-    size_t pos = 0;
-    while (pos < decls->size()) {
-      LocalType type = decls->at(pos++);
-      size_t count = 1;
-      while (pos < decls->size() && decls->at(pos) == type) {
-        pos++;
-        count++;
-      }
-
+    for (auto p : decls.local_types) {
+      LocalType type = p.first;
+      uint32_t count = p.second;
       os << " " << count << " " << WasmOpcodes::TypeName(type);
     }
     os << std::endl;
 
     for (const byte* locals = body.start; locals < pc; locals++) {
       printf(" 0x%02x,", *locals);
     }
     printf("\n");
   }
-  delete decls;
 
   printf("// body: \n");
   std::vector<int> arity_stack;
   while (pc < body.end) {
     int arity = decoder.OpcodeArity(pc);
     size_t length = decoder.OpcodeLength(pc);
 
     for (auto arity : arity_stack) {
       printf("  ");
       USE(arity);
@@ skipping 49 matching lines @@
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   SR_WasmDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8