[wasm] factor lower level utilties out of WasmFullDecoder

src/wasm/wasm-interpreter.cc

 // Copyright 2016 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/wasm/wasm-interpreter.h"
 
 #include "src/utils.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/function-body-decoder.h"
 #include "src/wasm/wasm-external-refs.h"
@@ skipping 910 matching lines @@
         &module_->function_tables[table_index];
     if (entry_index >= table->values.size()) return nullptr;
     uint32_t index = table->values[entry_index];
     if (index >= interpreter_code_.size()) return nullptr;
     return GetCode(index);
   }
 
   InterpreterCode* Preprocess(InterpreterCode* code) {
     if (code->targets == nullptr && code->start) {
       // Compute the control targets map and the local declarations.
-      CHECK(DecodeLocalDecls(code->locals, code->start, code->end));
+      CHECK(DecodeLocalDecls(&code->locals, code->start, code->end));
       code->targets = new (zone_) ControlTransfers(
           zone_, &code->locals, code->orig_start, code->orig_end);
     }
     return code;
   }
 
   int AddFunction(const WasmFunction* function, const byte* code_start,
                   const byte* code_end) {
     InterpreterCode code = {
         function, BodyLocalDecls(zone_),         code_start,
@@ skipping 121 matching lines @@
   // Entries on the stack of functions being evaluated.
   struct Frame {
     InterpreterCode* code;
     pc_t call_pc;
     pc_t ret_pc;
     sp_t sp;
 
     // Limit of parameters.
     sp_t plimit() { return sp + code->function->sig->parameter_count(); }
     // Limit of locals.
-    sp_t llimit() { return plimit() + code->locals.total_local_count; }
+    sp_t llimit() { return plimit() + code->locals.type_list.size(); }
   };
 
   struct Block {
     pc_t pc;
     sp_t sp;
     size_t fp;
     unsigned arity;
   };
 
   CodeMap* codemap_;
@@ skipping 28 matching lines @@
     frames_.push_back({code, 0, 0, stack_.size() - arity});
     blocks_.push_back(
         {0, stack_.size(), frames_.size(),
          static_cast<uint32_t>(code->function->sig->return_count())});
     frames_.back().ret_pc = InitLocals(code);
     TRACE("  => push func#%u @%zu\n", code->function->func_index,
           frames_.back().ret_pc);
   }
 
   pc_t InitLocals(InterpreterCode* code) {
-    for (auto p : code->locals.local_types) {
+    for (auto p : code->locals.type_list) {
       WasmVal val;
-      switch (p.first) {
+      switch (p) {
         case kWasmI32:
           val = WasmVal(static_cast<int32_t>(0));
           break;
         case kWasmI64:
           val = WasmVal(static_cast<int64_t>(0));
           break;
         case kWasmF32:
           val = WasmVal(static_cast<float>(0));
           break;
         case kWasmF64:
           val = WasmVal(static_cast<double>(0));
           break;
         default:
           UNREACHABLE();
           break;
       }
-      stack_.insert(stack_.end(), p.second, val);
+      stack_.push_back(val);
     }
-    return code->locals.decls_encoded_size;
+    return code->locals.encoded_size;
   }
 
   void CommitPc(pc_t pc) {
     if (!frames_.empty()) {
       frames_.back().ret_pc = pc;
     }
   }
 
   bool SkipBreakpoint(InterpreterCode* code, pc_t pc) {
     if (pc == break_pc_) {
@@ skipping 639 matching lines @@
 void WasmInterpreter::Run() { internals_->threads_[0]->Run(); }
 
 void WasmInterpreter::Pause() { internals_->threads_[0]->Pause(); }
 
 bool WasmInterpreter::SetBreakpoint(const WasmFunction* function, pc_t pc,
                                     bool enabled) {
   InterpreterCode* code = internals_->codemap_.FindCode(function);
   if (!code) return false;
   size_t size = static_cast<size_t>(code->end - code->start);
   // Check bounds for {pc}.
-  if (pc < code->locals.decls_encoded_size || pc >= size) return false;
+  if (pc < code->locals.encoded_size || pc >= size) return false;
   // Make a copy of the code before enabling a breakpoint.
   if (enabled && code->orig_start == code->start) {
     code->start = reinterpret_cast<byte*>(zone_.New(size));
     memcpy(code->start, code->orig_start, size);
     code->end = code->start + size;
   }
   bool prev = code->start[pc] == kInternalBreakpoint;
   if (enabled) {
     code->start[pc] = kInternalBreakpoint;
   } else {
     code->start[pc] = code->orig_start[pc];
   }
   return prev;
 }
 
 bool WasmInterpreter::GetBreakpoint(const WasmFunction* function, pc_t pc) {
   InterpreterCode* code = internals_->codemap_.FindCode(function);
   if (!code) return false;
   size_t size = static_cast<size_t>(code->end - code->start);
   // Check bounds for {pc}.
-  if (pc < code->locals.decls_encoded_size || pc >= size) return false;
+  if (pc < code->locals.encoded_size || pc >= size) return false;
   // Check if a breakpoint is present at that place in the code.
   return code->start[pc] == kInternalBreakpoint;
 }
 
 bool WasmInterpreter::SetTracing(const WasmFunction* function, bool enabled) {
   UNIMPLEMENTED();
   return false;
 }
 
 int WasmInterpreter::GetThreadCount() {
@@ skipping 53 matching lines @@
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, nullptr, start, end);
   return targets.map_;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8