[wasm] Initial signal handler

src/isolate.cc

 // Copyright 2012 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/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 1183 matching lines @@
 
   // Special handling of termination exceptions, uncatchable by JavaScript and
   // Wasm code, we unwind the handlers until the top ENTRY handler is found.
   bool catchable_by_js = is_catchable_by_javascript(exception);
 
   // Compute handler and stack unwinding information by performing a full walk
   // over the stack and dispatching according to the frame type.
   for (StackFrameIterator iter(this); !iter.done(); iter.Advance()) {
     StackFrame* frame = iter.frame();
 
+    if (frame->is_wasm()) {
+      trap_handler::ClearThreadInWasm();

[Mark Seaborn, 2017/02/17 21:41:12]

The other calls are guarded by "if (trap_handler::ShouldEnableTrapHandler())"

Maybe that guard should go into trap_handler::Set/ClearThreadInWasm()?

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

Is it intentional that ClearThreadInWasm is called multiple times here?

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

+1 and make the method inline

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

Originally, it didn't really matter either way since ClearThreadInWasm was
idempotent. Just calling ClearThreadInWasm is probably cheaper than determining
whether to call it.

However, I made Set/ClearThreadInWasm DCHECK the correct state first, so now we
can't call them multiple times. I've added IsThreadInWasm() to the if condition
here.

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

Done.

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

Done.

+    }
+
     // For JSEntryStub frames we always have a handler.
     if (frame->is_entry() || frame->is_entry_construct()) {
       StackHandler* handler = frame->top_handler();
 
       // Restore the next handler.
       thread_local_top()->handler_ = handler->next()->address();
 
       // Gather information from the handler.
       code = frame->LookupCode();
       handler_sp = handler->address() + StackHandlerConstants::kSize;
@@ skipping 11 matching lines @@
           // argument slots on the stack are dropped as returning would.
           Address return_sp = frame->fp() +
                               StandardFrameConstants::kFixedFrameSizeAboveFp -
                               stack_slots * kPointerSize;
 
           // Gather information from the frame.
           code = frame->LookupCode();
 
           handler_sp = return_sp;
           handler_fp = frame->fp();
+
+          // This is going to be handled by Wasm, so we need to set the TLS flag
+          // again.
+          if (trap_handler::ShouldEnableTrapHandler()) {
+            trap_handler::SetThreadInWasm();
+          }
+
           break;
         }
       }
     }
 
     // For optimized frames we perform a lookup in the handler table.
     if (frame->is_optimized() && catchable_by_js) {
       OptimizedFrame* js_frame = static_cast<OptimizedFrame*>(frame);
       int stack_slots = 0;  // Will contain stack slot count of frame.
       offset = js_frame->LookupExceptionHandlerInTable(&stack_slots, nullptr);
@@ skipping 2408 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8