[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/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 93 matching lines @@
 Node* BuildCallToRuntime(Runtime::FunctionId f, JSGraph* jsgraph,
                          Node** parameters, int parameter_count,
                          Node** effect_ptr, Node* control) {
   return BuildCallToRuntimeWithContext(f, jsgraph, jsgraph->NoContextConstant(),
                                        parameters, parameter_count, effect_ptr,
                                        control);
 }
 
 }  // namespace
 
-// TODO(eholk): Support trap handlers on other platforms.
-#if V8_TARGET_ARCH_X64 && V8_OS_LINUX
-const bool kTrapHandlerSupported = true;
-#else
-const bool kTrapHandlerSupported = false;
-#endif
-
 // A helper that handles building graph fragments for trapping.
 // To avoid generating a ton of redundant code that just calls the runtime
 // to trap, we generate a per-trap-reason block of code that all trap sites
 // in this function will branch to.
 class WasmTrapHelper : public ZoneObject {
  public:
   explicit WasmTrapHelper(WasmGraphBuilder* builder)
       : builder_(builder),
         jsgraph_(builder->jsgraph()),
         graph_(builder->jsgraph() ? builder->jsgraph()->graph() : nullptr) {}
@@ skipping 2669 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::UseTrapHandler()) {
+    // TODO(eholk): Set the flag directly without a runtime call. We should be
+    // able to store directly to a location in the isolate (later TLS) that sets
+    // the g_thread_in_wasm_code flag.
+    BuildCallToRuntime(Runtime::kSetThreadInWasm, jsgraph(), 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::UseTrapHandler()) {
+    // TODO(eholk): Set the flag directly without a runtime call. We should be
+    // able to store directly to a location in the isolate (later TLS) that sets
+    // the g_thread_in_wasm_code flag.
+    BuildCallToRuntime(Runtime::kClearThreadInWasm, jsgraph(), 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 26 matching lines @@
                                          jsgraph(), context, nullptr, 0,
                                          effect_, *control_));
     return;
   }
 
   Node** args = Buffer(wasm_count + 7);
 
   Node* call;
   bool direct_call = false;
 
+  if (trap_handler::UseTrapHandler()) {
+    BuildCallToRuntime(Runtime::kClearThreadInWasm, jsgraph(), 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::UseTrapHandler()) {
+    BuildCallToRuntime(Runtime::kSetThreadInWasm, jsgraph(), 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 249 matching lines @@
   trap_->AddTrapIfFalse(wasm::kTrapMemOutOfBounds, cond, position);
 }
 
 Node* WasmGraphBuilder::LoadMem(wasm::ValueType type, MachineType memtype,
                                 Node* index, uint32_t offset,
                                 uint32_t alignment,
                                 wasm::WasmCodePosition position) {
   Node* load;
 
   // WASM semantics throw on OOB. Introduce explicit bounds check.
-  if (!FLAG_wasm_trap_handler || !kTrapHandlerSupported) {
+  if (!FLAG_wasm_trap_handler || !V8_TRAP_HANDLER_SUPPORTED) {
     BoundsCheckMem(memtype, index, offset, position);
   }
   bool aligned = static_cast<int>(alignment) >=
                  ElementSizeLog2Of(memtype.representation());
 
   if (aligned ||
       jsgraph()->machine()->UnalignedLoadSupported(memtype, alignment)) {
-    if (FLAG_wasm_trap_handler && kTrapHandlerSupported) {
+    if (FLAG_wasm_trap_handler && V8_TRAP_HANDLER_SUPPORTED) {
       DCHECK(FLAG_wasm_guard_pages);
       Node* position_node = jsgraph()->Int32Constant(position);
       load = graph()->NewNode(jsgraph()->machine()->ProtectedLoad(memtype),
                               MemBuffer(offset), index, position_node, *effect_,
                               *control_);
     } else {
       load = graph()->NewNode(jsgraph()->machine()->Load(memtype),
                               MemBuffer(offset), index, *effect_, *control_);
     }
   } else {
     // TODO(eholk): Support unaligned loads with trap handlers.
-    DCHECK(!FLAG_wasm_trap_handler || !kTrapHandlerSupported);
+    DCHECK(!FLAG_wasm_trap_handler || !V8_TRAP_HANDLER_SUPPORTED);
     load = graph()->NewNode(jsgraph()->machine()->UnalignedLoad(memtype),
                             MemBuffer(offset), index, *effect_, *control_);
   }
 
   *effect_ = load;
 
 #if defined(V8_TARGET_BIG_ENDIAN)
   load = BuildChangeEndianness(load, memtype, type);
 #endif
 
@@ skipping 13 matching lines @@
   return load;
 }
 
 
 Node* WasmGraphBuilder::StoreMem(MachineType memtype, Node* index,
                                  uint32_t offset, uint32_t alignment, Node* val,
                                  wasm::WasmCodePosition position) {
   Node* store;
 
   // WASM semantics throw on OOB. Introduce explicit bounds check.
-  if (!FLAG_wasm_trap_handler || !kTrapHandlerSupported) {
+  if (!FLAG_wasm_trap_handler || !V8_TRAP_HANDLER_SUPPORTED) {
     BoundsCheckMem(memtype, index, offset, position);
   }
   StoreRepresentation rep(memtype.representation(), kNoWriteBarrier);
 
   bool aligned = static_cast<int>(alignment) >=
                  ElementSizeLog2Of(memtype.representation());
 
 #if defined(V8_TARGET_BIG_ENDIAN)
   val = BuildChangeEndianness(val, memtype);
 #endif
 
   if (aligned ||
       jsgraph()->machine()->UnalignedStoreSupported(memtype, alignment)) {
-    if (FLAG_wasm_trap_handler && kTrapHandlerSupported) {
+    if (FLAG_wasm_trap_handler && V8_TRAP_HANDLER_SUPPORTED) {
       Node* position_node = jsgraph()->Int32Constant(position);
       store = graph()->NewNode(
           jsgraph()->machine()->ProtectedStore(memtype.representation()),
           MemBuffer(offset), index, val, position_node, *effect_, *control_);
     } else {
       StoreRepresentation rep(memtype.representation(), kNoWriteBarrier);
       store =
           graph()->NewNode(jsgraph()->machine()->Store(rep), MemBuffer(offset),
                            index, val, *effect_, *control_);
     }
   } else {
     // TODO(eholk): Support unaligned stores with trap handlers.
-    DCHECK(!FLAG_wasm_trap_handler || !kTrapHandlerSupported);
+    DCHECK(!FLAG_wasm_trap_handler || !V8_TRAP_HANDLER_SUPPORTED);
     UnalignedStoreRepresentation rep(memtype.representation());
     store =
         graph()->NewNode(jsgraph()->machine()->UnalignedStore(rep),
                          MemBuffer(offset), index, val, *effect_, *control_);
   }
 
   *effect_ = store;
 
   return store;
 }
@@ skipping 945 matching lines @@
     wasm::ErrorThrower* thrower, Isolate* isolate,
     wasm::ModuleBytesEnv* module_env, const wasm::WasmFunction* function) {
   WasmCompilationUnit unit(isolate, module_env, function);
   unit.ExecuteCompilation();
   return unit.FinishCompilation(thrower);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8