[wasm] Implement an interpreter for WASM.

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>
 
+#include "src/base/accounting-allocator.h"
 #include "src/base/utils/random-number-generator.h"
 
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/int64-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/compiler/zone-pool.h"
 
 #include "src/wasm/ast-decoder.h"
+#include "src/wasm/wasm-interpreter.h"
 #include "src/wasm/wasm-js.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-opcodes.h"
 
 #include "src/zone.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/call-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 
 // TODO(titzer): pull WASM_64 up to a common header.
 #if !V8_TARGET_ARCH_32_BIT || V8_TARGET_ARCH_X64
 #define WASM_64 1
 #else
 #define WASM_64 0
 #endif
 
 static const uint32_t kMaxFunctions = 10;
+#define WASM_INTERPRETER 1
 
 // TODO(titzer): check traps more robustly in tests.
 // Currently, in tests, we just return 0xdeadbeef from the function in which
 // the trap occurs if the runtime context is not available to throw a JavaScript
 // exception.
 #define CHECK_TRAP32(x) \
   CHECK_EQ(0xdeadbeef, (bit_cast<uint32_t>(x)) & 0xFFFFFFFF)
 #define CHECK_TRAP64(x) \
   CHECK_EQ(0xdeadbeefdeadbeef, (bit_cast<uint64_t>(x)) & 0xFFFFFFFFFFFFFFFF)
 #define CHECK_TRAP(x) CHECK_TRAP32(x)
@@ skipping 13 matching lines @@
 using namespace v8::internal::compiler;
 using namespace v8::internal::wasm;
 
 const uint32_t kMaxGlobalsSize = 128;
 
 // 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:
-  TestingModule() : instance_(&module_), global_offset(0) {
+  TestingModule()
+      : instance_(&module_),
+        global_offset(0),
+        interpreter_(&instance_, &allocator_) {
     module_.shared_isolate = CcTest::InitIsolateOnce();
     module = &module_;
     instance = &instance_;
     instance->module = &module_;
     instance->globals_start = global_data;
     instance->globals_size = kMaxGlobalsSize;
     instance->mem_start = nullptr;
     instance->mem_size = 0;
     linker = nullptr;
     origin = kWasmOrigin;
@@ skipping 78 matching lines @@
   uint32_t AddFunction(FunctionSig* sig, Handle<Code> code) {
     if (module->functions.size() == 0) {
       // TODO(titzer): Reserving space here to avoid the underlying WasmFunction
       // structs from moving.
       module->functions.reserve(kMaxFunctions);
     }
     uint32_t index = static_cast<uint32_t>(module->functions.size());
     module->functions.push_back(
         {sig, index, 0, 0, 0, 0, 0, 0, 0, 0, 0, false, false});
     instance->function_code.push_back(code);
+    WasmFunction* function = &module->functions.back();
+    int interpreter_index = interpreter_.AddFunctionForTesting(function);
+    DCHECK_EQ(index, static_cast<uint32_t>(interpreter_index));
     DCHECK_LT(index, kMaxFunctions);  // limited for testing.
     return index;
   }
 
   uint32_t AddJsFunction(FunctionSig* sig, const char* source) {
     Handle<JSFunction> jsfunc = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
         *v8::Local<v8::Function>::Cast(CompileRun(source))));
     uint32_t index = AddFunction(sig, Handle<Code>::null());
     Isolate* isolate = module->shared_isolate;
     WasmName module_name = ArrayVector("test");
@@ skipping 35 matching lines @@
     int table_size = static_cast<int>(module->function_table.size());
     for (int i = 0; i < table_size; i++) {
       int function_index = module->function_table[i];
       WasmFunction* function = &module->functions[function_index];
       instance->function_table->set(i, Smi::FromInt(function->sig_index));
       instance->function_table->set(i + table_size,
                                     *instance->function_code[function_index]);
     }
   }
 
+  WasmInterpreter* GetInterpreter() { return &interpreter_; }
+
  private:
   WasmModule module_;
   WasmModuleInstance instance_;
+  v8::base::AccountingAllocator allocator_;
   uint32_t global_offset;
   V8_ALIGNED(8) byte global_data[kMaxGlobalsSize];  // preallocated global data.
+  // TODO(titzer): This is ugly. Because the functions must be manually added
+  // to the interpreter for testing, it needs to be accessible to each creation
+  // of a WasmFunctionCompiler below.
+  WasmInterpreter interpreter_;
 
   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.
     CHECK_LT(global_offset, kMaxGlobalsSize);
     return &module->globals.back();
   }
@@ skipping 158 matching lines @@
 
  private:
   Node* inner_code_node_;
   Handle<Code> code_;
   Signature<MachineType>* signature_;
 };
 
 // A helper for compiling WASM functions for testing. This class can create a
 // standalone function if {module} is NULL or a function within a
 // {TestingModule}. It contains the internal state for compilation (i.e.
-// TurboFan graph) and, later, interpretation.
+// TurboFan graph) and interpretation (by adding to the interpreter manually).
 class WasmFunctionCompiler : public HandleAndZoneScope,
                              private GraphAndBuilders {
  public:
   explicit WasmFunctionCompiler(
       FunctionSig* sig, TestingModule* module,
       Vector<const char> debug_name = ArrayVector("<WASM UNNAMED>"))
       : GraphAndBuilders(main_zone()),
         jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
                 nullptr, this->machine()),
         sig(sig),
@@ skipping 33 matching lines @@
   Zone* zone() const { return graph()->zone(); }
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   void InitializeDescriptor() {
     if (descriptor_ == nullptr) {
       descriptor_ = testing_module_->GetWasmCallDescriptor(main_zone(), sig);
     }
   }
   CallDescriptor* descriptor() { return descriptor_; }
 
-  void Build(const byte* start, const byte* end) {
+  void Build(const byte* start, const byte* end,
+             WasmInterpreter* interpreter = nullptr) {
     // Build the TurboFan graph.
     local_decls.Prepend(&start, &end);
     TestBuildingGraph(main_zone(), &jsgraph, testing_module_, sig,
                       &source_position_table_, start, end);
-    delete[] start;
+#if WASM_INTERPRETER
+    // Build the interpreter code.
+    if (!testing_module_) {
+      // No module; the function was never added to the interpreter.
+      int index = interpreter->AddFunctionForTesting(function_);
+      CHECK_EQ(function_index_, index);
+    } else {
+      // Always use the interpreter from the module.
+      interpreter = testing_module_->GetInterpreter();
+    }
+    CHECK(interpreter->SetFunctionCodeForTesting(function(), start, end));
+// TODO(titzer): memory leak!!!!    delete[] start;

[Clemens Hammacher, 2016/05/12 15:20:55]

SetFunctionCodeForTesting could allocate memory for a copy of the code in its
zone.

+#endif
   }
 
   byte AllocateLocal(LocalType type) {
     uint32_t index = local_decls.AddLocals(1, type, sig);
     byte result = static_cast<byte>(index);
     DCHECK_EQ(index, result);
     return result;
   }
 
   Handle<Code> Compile() {
@@ skipping 62 matching lines @@
 class WasmRunner {
  public:
   WasmRunner(MachineType p0 = MachineType::None(),
              MachineType p1 = MachineType::None(),
              MachineType p2 = MachineType::None(),
              MachineType p3 = MachineType::None())
       : zone(&allocator_),
         compiled_(false),
         signature_(MachineTypeForC<ReturnType>() == MachineType::None() ? 0 : 1,
                    GetParameterCount(p0, p1, p2, p3), storage_),
-        compiler_(&signature_, nullptr) {
+        compiler_(&signature_, nullptr),
+        interpreter_(new WasmInterpreter(nullptr, &allocator_)) {
     InitSigStorage(p0, p1, p2, p3);
   }
 
   WasmRunner(TestingModule* module, MachineType p0 = MachineType::None(),
              MachineType p1 = MachineType::None(),
              MachineType p2 = MachineType::None(),
              MachineType p3 = MachineType::None())
       : zone(&allocator_),
         compiled_(false),
         signature_(MachineTypeForC<ReturnType>() == MachineType::None() ? 0 : 1,
                    GetParameterCount(p0, p1, p2, p3), storage_),
-        compiler_(&signature_, module) {
+        compiler_(&signature_, module),
+        interpreter_(nullptr) {
     DCHECK(module);
     InitSigStorage(p0, p1, p2, p3);
   }
 
   void InitSigStorage(MachineType p0, MachineType p1, MachineType p2,
                       MachineType p3) {
     int index = 0;
     MachineType ret = MachineTypeForC<ReturnType>();
     if (ret != MachineType::None()) {
       storage_[index++] = WasmOpcodes::LocalTypeFor(ret);
@@ skipping 11 matching lines @@
     wrapper_.Init(compiler_.descriptor(), p0, p1, p2, p3);
   }
 
   // Builds a graph from the given Wasm code and generates the machine
   // code and call wrapper for that graph. This method must not be called
   // more than once.
   void Build(const byte* start, const byte* end) {
     CHECK(!compiled_);
     compiled_ = true;
 
-    // Build the TF graph within the compiler.
-    compiler_.Build(start, end);
-    // Generate code.
-    Handle<Code> code = compiler_.Compile();
+    if (WASM_INTERPRETER) {
+      // Build the interpreter code.
+      compiler_.Build(start, end, interpreter_);
+    } else {
+      // Build the TF graph within the compiler.
+      compiler_.Build(start, end);
+      // Generate code.
+      Handle<Code> code = compiler_.Compile();
 
-    if (compiler_.testing_module_) {
-      // Update the table of function code in the module.
-      compiler_.testing_module_->SetFunctionCode(compiler_.function_index_,
-                                                 code);
+      if (compiler_.testing_module_) {
+        // Update the table of function code in the module.
+        compiler_.testing_module_->SetFunctionCode(compiler_.function_index_,
+                                                   code);
+      }
+
+      wrapper_.SetInnerCode(code);
     }
-
-    wrapper_.SetInnerCode(code);
   }
 
-  ReturnType Call() { return Call(0, 0, 0, 0); }
+  ReturnType Call() {
+    if (WASM_INTERPRETER) {
+      return CallInterpreter(nullptr, 0);
+    } else {
+      return Call(0, 0, 0, 0);
+    }
+  }
 
   template <typename P0>
   ReturnType Call(P0 p0) {
-    return Call(p0, 0, 0, 0);
+    if (WASM_INTERPRETER) {
+      WasmVal args[] = {WasmVal(p0)};
+      return CallInterpreter(args, 1);
+    } else {
+      return Call(p0, 0, 0, 0);
+    }
   }
 
   template <typename P0, typename P1>
   ReturnType Call(P0 p0, P1 p1) {
-    return Call(p0, p1, 0, 0);
+    if (WASM_INTERPRETER) {
+      WasmVal args[] = {WasmVal(p0), WasmVal(p1)};
+      return CallInterpreter(args, 2);
+    } else {
+      return Call(p0, p1, 0, 0);
+    }
   }
 
   template <typename P0, typename P1, typename P2>
   ReturnType Call(P0 p0, P1 p1, P2 p2) {
-    return Call(p0, p1, p2, 0);
+    if (WASM_INTERPRETER) {
+      WasmVal args[] = {WasmVal(p0), WasmVal(p1), WasmVal(p2)};
+      return CallInterpreter(args, 3);
+    } else {
+      return Call(p0, p1, p2, 0);
+    }
   }
 
   template <typename P0, typename P1, typename P2, typename P3>
   ReturnType Call(P0 p0, P1 p1, P2 p2, P3 p3) {
-    CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
-                               wrapper_.GetWrapperCode(), wrapper_.signature());
-    ReturnType return_value;
-    int32_t result = runner.Call<void*, void*, void*, void*, void*>(
-        &p0, &p1, &p2, &p3, &return_value);
-    CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
-    return return_value;
+    if (WASM_INTERPRETER) {
+      WasmVal args[] = {WasmVal(p0), WasmVal(p1), WasmVal(p2), WasmVal(p3)};
+      return CallInterpreter(args, 4);
+    } else {
+      CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
+                                 wrapper_.GetWrapperCode(),
+                                 wrapper_.signature());
+      ReturnType return_value;
+      int32_t result = runner.Call<void*, void*, void*, void*, void*>(
+          &p0, &p1, &p2, &p3, &return_value);
+      CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
+      return return_value;
+    }
+  }
+
+  ReturnType CallInterpreter(WasmVal* args, int count) {
+    CHECK_EQ(count,
+             static_cast<int>(compiler_.function()->sig->parameter_count()));
+    WasmInterpreter* interpreter = GetInterpreter();
+
+    WasmInterpreter::Thread& thread = interpreter->GetThread(0);
+    thread.Reset();
+    thread.PushFrame(compiler_.function(), args);
+    if (thread.Run() == WasmInterpreter::FINISHED) {
+      WasmVal val = thread.GetReturnValue();
+      return val.to<ReturnType>();
+    } else if (thread.state() == WasmInterpreter::TRAPPED) {
+      // TODO(titzer): return the correct trap code
+      int64_t result = 0xdeadbeefdeadbeef;
+      return static_cast<ReturnType>(result);
+    } else {

[ahaas, 2016/05/13 12:18:55]

if the program is more than 1000 (wasm-interpreter.cc::kRunSteps) instructions
long, then the program reaches the PAUSED state. 

+      // TODO(titzer): falling off end
+      ReturnType val = 0;
+      return val;
+    }
   }
 
   byte AllocateLocal(LocalType type) { return compiler_.AllocateLocal(type); }
 
+  WasmInterpreter* GetInterpreter() {
+    return compiler_.testing_module_
+               ? compiler_.testing_module_->GetInterpreter()
+               : interpreter_;
+  }
+
+  WasmFunction* function() { return compiler_.function(); }
+
  protected:
   v8::base::AccountingAllocator allocator_;
   Zone zone;
   bool compiled_;
   LocalType storage_[WASM_RUNNER_MAX_NUM_PARAMETERS];
   FunctionSig signature_;
   WasmFunctionCompiler compiler_;
   WasmFunctionWrapper<ReturnType> wrapper_;
+  WasmInterpreter* interpreter_;
 
   static size_t GetParameterCount(MachineType p0, MachineType p1,
                                   MachineType p2, MachineType p3) {
     if (p0 == MachineType::None()) return 0;
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif