[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 1185 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::EnableTrapHandler()) {

[titzer, 2017/01/09 09:26:56]

I think this logic is correct, but maybe it would be more straightforward to
just unconditionally set the ThreadInWasm flag to be true if the handler frame
is wasm, and false otherwise?

[Eric Holk, 2017/01/10 23:10:48]

Was the concern about the extra call to EnableTrapHandler()? If so, I went ahead
and removed that.

Otherwise, we want to clear the ThreadInWasm flag when we unwind out of a Wasm
frame, which is what's happening here.

+      trap_handler::ClearThreadInWasm();
+    }
+
     // 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::EnableTrapHandler()) {
+            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 2413 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8