[wasm] Add a cctest for the stack on a wasm trap

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 392 matching lines @@
   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.
 class WasmFunctionCompiler : public HandleAndZoneScope,
                              private GraphAndBuilders {
  public:
-  explicit WasmFunctionCompiler(FunctionSig* sig, TestingModule* module)
+  explicit WasmFunctionCompiler(FunctionSig* sig, TestingModule* module,
+                                const char* debug_name = "wasm_unnamed")

[JF, 2016/04/12 19:38:54]

It's probably clearer to give it a name with unusual characters, like "WASM
UNNAMED>".

[Clemens Hammacher, 2016/04/13 07:45:18]

Done.

       : GraphAndBuilders(main_zone()),
         jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
                 nullptr, this->machine()),
         sig(sig),
         descriptor_(nullptr),
-        testing_module_(module) {
+        testing_module_(module),
+        debug_name(debug_name) {
     if (module) {
       // Get a new function from the testing module.
       function_ = nullptr;
       function_index_ = module->AddFunction(sig, Handle<Code>::null());
     } else {
       // Create our own function.
       function_ = new WasmFunction();
       function_->sig = sig;
       function_index_ = 0;
     }
   }
 
   ~WasmFunctionCompiler() {
     if (function_) delete function_;
   }
 
   JSGraph jsgraph;
   FunctionSig* sig;
   // The call descriptor is initialized when the function is compiled.
   CallDescriptor* descriptor_;
   TestingModule* testing_module_;
+  const char* debug_name;
   WasmFunction* function_;
   int function_index_;
   LocalDeclEncoder local_decls;
 
   Isolate* isolate() { return main_isolate(); }
   Graph* graph() const { return main_graph_; }
   Zone* zone() const { return graph()->zone(); }
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   void InitializeDescriptor() {
@@ skipping 16 matching lines @@
     DCHECK_EQ(index, result);
     return result;
   }
 
   Handle<Code> Compile() {
     InitializeDescriptor();
     CallDescriptor* desc = descriptor_;
     if (kPointerSize == 4) {
       desc = testing_module_->GetI32WasmCallDescriptor(this->zone(), desc);
     }
-    CompilationInfo info("wasm compile", this->isolate(), this->zone(),
+    CompilationInfo info(debug_name, this->isolate(), this->zone(),
                          Code::ComputeFlags(Code::WASM_FUNCTION));
     Handle<Code> result =
         Pipeline::GenerateCodeForTesting(&info, desc, this->graph());
 #ifdef ENABLE_DISASSEMBLER
     if (!result.is_null() && FLAG_print_opt_code) {
       OFStream os(stdout);
       result->Disassemble("wasm code", os);
     }
 #endif
 
     return result;
   }
 
   uint32_t CompileAndAdd(uint16_t sig_index = 0) {
     CHECK(testing_module_);
     function()->sig_index = sig_index;
     Handle<Code> code = Compile();
     testing_module_->SetFunctionCode(function_index_, code);
     return static_cast<uint32_t>(function_index_);
   }
 
   WasmFunction* function() {
     if (function_) return function_;
     return &testing_module_->module->functions[function_index_];
   }
+
+  void SetModuleContext() {
+    // Set the context, such that e.g. runtime functions can be called
+    if (!testing_module_->instance->context.is_null()) {
+      CHECK(testing_module_->instance->context.is_identical_to(
+          main_isolate()->native_context()));
+      return;
+    }
+    testing_module_->instance->context = main_isolate()->native_context();
+  }
 };
 
 // A helper class to build graphs from Wasm bytecode, generate machine
 // code, and run that code.
 template <typename ReturnType>
 class WasmRunner {
  public:
   WasmRunner(MachineType p0 = MachineType::None(),
              MachineType p1 = MachineType::None(),
              MachineType p2 = MachineType::None(),
@@ skipping 105 matching lines @@
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif