[wasm] prototype for breakpoint support.

test/cctest/wasm/wasm-run-utils.h

 // 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 55 matching lines @@
 
 // A helper for module environments that adds the ability to allocate memory
 // and global variables. Contains a built-in {WasmModule} and
 // {WasmModuleInstance}.
 class TestingModule : public ModuleEnv {
  public:
   explicit TestingModule(WasmExecutionMode mode = kExecuteCompiled)
       : execution_mode_(mode),
         instance_(&module_),
         isolate_(CcTest::InitIsolateOnce()),
+        zone_(&allocator_),
         global_offset(0),
         interpreter_(mode == kExecuteInterpreted
-                         ? new WasmInterpreter(&instance_, &allocator_)
+                         ? new WasmInterpreter(&instance_, &zone_)
                          : nullptr) {
     module = &module_;
     instance = &instance_;
     instance->module = &module_;
     instance->globals_start = global_data;
     module_.globals_size = kMaxGlobalsSize;
     instance->mem_start = nullptr;
     instance->mem_size = 0;
     origin = kWasmOrigin;
     memset(global_data, 0, sizeof(global_data));
@@ skipping 144 matching lines @@
 
   WasmInterpreter* interpreter() { return interpreter_; }
   WasmExecutionMode execution_mode() { return execution_mode_; }
 
  private:
   WasmExecutionMode execution_mode_;
   WasmModule module_;
   WasmModuleInstance instance_;
   Isolate* isolate_;
   v8::base::AccountingAllocator allocator_;
+  Zone zone_;
   uint32_t global_offset;
   V8_ALIGNED(8) byte global_data[kMaxGlobalsSize];  // preallocated global data.
   WasmInterpreter* interpreter_;
 
   const WasmGlobal* AddGlobal(MachineType mem_type) {
     byte size = WasmOpcodes::MemSize(mem_type);
     global_offset = (global_offset + size - 1) & ~(size - 1);  // align
     module_.globals.push_back({0, 0, mem_type, global_offset, false});
     global_offset += size;
     // limit number of globals.
@@ skipping 185 matching lines @@
         debug_name_(debug_name),
         local_decls(main_zone(), sig),
         source_position_table_(this->graph()),
         interpreter_(nullptr) {
     // Create our own function.
     function_ = new WasmFunction();
     function_->sig = sig;
     function_->func_index = 0;
     function_->sig_index = 0;
     if (mode == kExecuteInterpreted) {
-      interpreter_ = new WasmInterpreter(nullptr, zone()->allocator());
+      interpreter_ = new WasmInterpreter(nullptr, zone());
       int index = interpreter_->AddFunctionForTesting(function_);
       CHECK_EQ(0, index);
     }
   }
 
   explicit WasmFunctionCompiler(
       FunctionSig* sig, TestingModule* module,
       Vector<const char> debug_name = ArrayVector("<WASM UNNAMED>"))
       : GraphAndBuilders(main_zone()),
         execution_mode_(module->execution_mode()),
@@ skipping 295 matching lines @@
 // interpreter.
 #define WASM_EXEC_TEST(name)                                               \
   void RunWasm_##name(WasmExecutionMode execution_mode);                   \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); }       \
   TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif