[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 2759 matching lines @@
     Node* param = Param(i + 1);
     Node* wasm_param = FromJS(param, context, sig->GetParam(i));
     args[pos++] = wasm_param;
     if (jsgraph()->machine()->Is32() && sig->GetParam(i) == wasm::kWasmI64) {
       // We make up the high word with SAR to get the proper sign extension.
       args[pos++] = graph()->NewNode(jsgraph()->machine()->Word32Sar(),
                                      wasm_param, jsgraph()->Int32Constant(31));
     }
   }
 
+  // Set the ThreadInWasm flag before we do the actual call.
+  Node* parameters[] = {};
+  BuildCallToRuntime(Runtime::kSetThreadInWasm, jsgraph(),
+                     jsgraph()->isolate()->native_context(), parameters, 0,
+                     effect_, *control_);
+
   args[pos++] = *effect_;
   args[pos++] = *control_;
 
   // Call the WASM code.
   CallDescriptor* desc =
       wasm::ModuleEnv::GetWasmCallDescriptor(jsgraph()->zone(), sig);
   if (jsgraph()->machine()->Is32()) {
     desc = wasm::ModuleEnv::GetI32WasmCallDescriptor(jsgraph()->zone(), desc);
   }
   Node* call = graph()->NewNode(jsgraph()->common()->Call(desc), count, args);
   *effect_ = call;
+
+  // Clear the ThreadInWasmFlag
+  BuildCallToRuntime(Runtime::kClearThreadInWasm, jsgraph(),
+                     jsgraph()->isolate()->native_context(), parameters, 0,
+                     effect_, *control_);
+
   Node* retval = call;
   if (jsgraph()->machine()->Is32() && sig->return_count() > 0 &&
       sig->GetReturn(0) == wasm::kWasmI64) {
     // The return values comes as two values, we pick the low word.
     retval = graph()->NewNode(jsgraph()->common()->Projection(0), retval,
                               graph()->start());
   }
   Node* jsval = ToJS(
       retval, sig->return_count() == 0 ? wasm::kWasmStmt : sig->GetReturn());
   Return(jsval);
@@ skipping 31 matching lines @@
   Isolate* isolate = jsgraph()->isolate();
   CallDescriptor* desc;
   Node* start = Start(param_count + 3);
   *effect_ = start;
   *control_ = start;
   Node** args = Buffer(wasm_count + 7);
 
   Node* call;
   bool direct_call = false;
 
+  Node* parameters[] = {};
+  BuildCallToRuntime(Runtime::kClearThreadInWasm, jsgraph(),
+                     jsgraph()->isolate()->native_context(), parameters, 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);
 
+  BuildCallToRuntime(Runtime::kSetThreadInWasm, jsgraph(),
+                     jsgraph()->isolate()->native_context(), parameters, 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);
 }
 
 Node* WasmGraphBuilder::MemBuffer(uint32_t offset) {
@@ skipping 770 matching lines @@
                       Smi::FromInt(instruction.instr_offset));
     fn_protected->set(Code::kTrapDataSize * i + Code::kTrapLandingOffset,
                       Smi::FromInt(instruction.landing_offset));
   }
   return fn_protected;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8