[WASM] Implements catch for the wasm low level exception mechanism.

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 1127 matching lines @@
 
 Object* Isolate::UnwindAndFindHandler() {
   Object* exception = pending_exception();
 
   Code* code = nullptr;
   Context* context = nullptr;
   intptr_t offset = 0;
   Address handler_sp = nullptr;
   Address handler_fp = nullptr;
 
-  // Special handling of termination exceptions, uncatchable by JavaScript code,
-  // we unwind the handlers until the top ENTRY handler is found.
+  // 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);
+  bool catchable_by_wasm =
+      FLAG_wasm_eh_prototype && is_catchable_by_wasm(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();
 
     // 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;
       offset = Smi::cast(code->handler_table()->get(0))->value();
       break;
     }
 
+    if (frame->is_wasm() && catchable_by_wasm) {

[titzer, 2016/09/28 17:09:14]

What about nesting this whole thing inside a if(FLAG_eh_wasm_prototype) ?

That way, it is essentially no overhead without that flag on.

[John, 2016/09/29 13:28:31]

Done.

+      int stack_slots = 0;  // Will contain stack slot count of frame.
+      WasmFrame* wasm_frame = static_cast<WasmFrame*>(frame);
+      offset = wasm_frame->LookupExceptionHandlerInTable(&stack_slots);
+      if (offset >= 0) {
+        // Compute the stack pointer from the frame pointer. This ensures that
+        // 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();
+        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);
       if (offset >= 0) {
         // Compute the stack pointer from the frame pointer. This ensures that
         // argument slots on the stack are dropped as returning would.
         Address return_sp = frame->fp() +
                             StandardFrameConstants::kFixedFrameSizeAboveFp -
@@ skipping 2110 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8