[wasm] Initial signal handler

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/isolate-inl.h"
 
@@ skipping 2789 matching lines @@
   int pos = 0;
   args[pos++] = HeapConstant(wasm_code);
 
   // Convert JS parameters to WASM numbers.
   for (int i = 0; i < wasm_count; ++i) {
     Node* param = Param(i + 1);
     Node* wasm_param = FromJS(param, context, sig->GetParam(i));
     args[pos++] = wasm_param;
   }
 
+  // Set the ThreadInWasm flag before we do the actual call.
+  if (trap_handler::ShouldEnableTrapHandler()) {
+    BuildCallToRuntime(Runtime::kSetThreadInWasm, jsgraph(),

[ahaas, 2017/02/20 09:27:23]

I wonder if we could set this flag without a runtime call. I think we should
make calls from JavaScript to WebAssembly as fast as possible. I think this is
critical to support the use case of providing WebAssembly libraries for
JavaScript. Could you add a TODO for this?

[titzer, 2017/02/20 09:50:08]

+1. I think you can embed a store directly to a location in the isolate (later
TLS) that sets the ThreadInWasm flag.

[Eric Holk, 2017/02/23 02:16:55]

TODO is added.

+                       jsgraph()->isolate()->native_context(), nullptr, 0,
+                       effect_, *control_);
+  }
+
   args[pos++] = *effect_;
   args[pos++] = *control_;
 
   // Call the WASM code.
   CallDescriptor* desc =
       wasm::ModuleEnv::GetWasmCallDescriptor(jsgraph()->zone(), sig);
 
   Node* call = graph()->NewNode(jsgraph()->common()->Call(desc), count, args);
   *effect_ = call;
+
+  // Clear the ThreadInWasmFlag
+  if (trap_handler::ShouldEnableTrapHandler()) {
+    BuildCallToRuntime(Runtime::kClearThreadInWasm, jsgraph(),

[ahaas, 2017/02/20 09:27:24]

Is this runtime function called when WebAssembly throws a trap, e.g. division by
zero?

[Eric Holk, 2017/02/23 02:16:55]

The changes in isolate.cc will clear the flag when unwinding out of a Wasm
frame, which should handle this case.

+                       jsgraph()->isolate()->native_context(), nullptr, 0,
+                       effect_, *control_);
+  }
+
   Node* retval = call;
   Node* jsval = ToJS(
       retval, sig->return_count() == 0 ? wasm::kWasmStmt : sig->GetReturn());
   Return(jsval);
 }
 
 int WasmGraphBuilder::AddParameterNodes(Node** args, int pos, int param_count,
                                         wasm::FunctionSig* sig) {
   // Convert WASM numbers to JS values.
   int param_index = 0;
@@ skipping 24 matching lines @@
                               jsgraph()->isolate()->native_context(), nullptr,
                               0, effect_, *control_));
     return;
   }
 
   Node** args = Buffer(wasm_count + 7);
 
   Node* call;
   bool direct_call = false;
 
+  if (trap_handler::ShouldEnableTrapHandler()) {
+    BuildCallToRuntime(Runtime::kClearThreadInWasm, jsgraph(),
+                       jsgraph()->isolate()->native_context(), nullptr, 0,
+                       effect_, *control_);
+  }
+
   if (target->IsJSFunction()) {
     Handle<JSFunction> function = Handle<JSFunction>::cast(target);
     if (function->shared()->internal_formal_parameter_count() == wasm_count) {
       direct_call = true;
       int pos = 0;
       args[pos++] = jsgraph()->Constant(target);  // target callable.
       // Receiver.
       if (is_sloppy(function->shared()->language_mode()) &&
           !function->shared()->native()) {
         args[pos++] =
@@ skipping 44 matching lines @@
     args[pos++] = HeapConstant(isolate->native_context());
     args[pos++] = *effect_;
     args[pos++] = *control_;
 
     call = graph()->NewNode(jsgraph()->common()->Call(desc), pos, args);
   }
 
   *effect_ = call;
   SetSourcePosition(call, 0);
 
+  if (trap_handler::ShouldEnableTrapHandler()) {
+    BuildCallToRuntime(Runtime::kSetThreadInWasm, jsgraph(),
+                       jsgraph()->isolate()->native_context(), nullptr, 0,
+                       effect_, *control_);
+  }
+
   // Convert the return value back.
   Node* i32_zero = jsgraph()->Int32Constant(0);
   Node* val = sig->return_count() == 0
                   ? i32_zero
                   : FromJS(call, HeapConstant(isolate->native_context()),
                            sig->GetReturn());
   Return(val);
 }
 
 void WasmGraphBuilder::BuildWasmInterpreterEntry(
@@ skipping 1197 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8