Move stack unwinding logic into the runtime.

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 <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/v8.h"
@@ skipping 892 matching lines @@
 
   thread_local_top()->catcher_ = can_be_caught_externally ?
       try_catch_handler() : NULL;
 
   // Set the exception being re-thrown.
   set_pending_exception(exception);
   return heap()->exception();
 }
 
 
+Object* Isolate::FindHandler() {
+  Object* exception = pending_exception();
+
+  // Determine target stack handler. Special handling of termination exceptions
+  // which are uncatchable by JavaScript code, we unwind the handlers until the
+  // top ENTRY handler is found.
+  StackHandler* handler =
+      StackHandler::FromAddress(Isolate::handler(thread_local_top()));
+  if (!is_catchable_by_javascript(exception)) {
+    while (!handler->is_js_entry()) handler = handler->next();
+  }
+
+  // Restore the next handler.
+  thread_local_top_.handler_ = handler->next()->address();
+
+  // Compute handler and stack unwinding information.
+  // TODO(mstarzinger): Extend this to perform actual stack-walk and take into
+  // account that TurboFan code can contain handlers as well.
+  Code* code = handler->code();
+  Context* context = handler->is_js_entry() ? nullptr : handler->context();
+  int offset = Smi::cast(code->handler_table()->get(handler->index()))->value();
+  Address handler_sp = handler->address() + StackHandlerConstants::kSize;
+  Address handler_fp = handler->frame_pointer();
+
+
+  // Store information to be consumed by the CEntryStub.
+  thread_local_top_.pending_handler_context_ = context;
+  thread_local_top_.pending_handler_code_ = code;
+  thread_local_top_.pending_handler_offset_ = offset;
+  thread_local_top_.pending_handler_fp_ = handler_fp;
+  thread_local_top_.pending_handler_sp_ = handler_sp;
+
+  // Return and clear pending exception.
+  clear_pending_exception();
+  return exception;
+}
+
+
 Object* Isolate::ThrowIllegalOperation() {
   if (FLAG_stack_trace_on_illegal) PrintStack(stdout);
   return Throw(heap_.illegal_access_string());
 }
 
 
 void Isolate::ScheduleThrow(Object* exception) {
   // When scheduling a throw we first throw the exception to get the
   // error reporting if it is uncaught before rescheduling it.
   Throw(exception);
@@ skipping 356 matching lines @@
   }
 
   // Save the message for reporting if the the exception remains uncaught.
   thread_local_top()->has_pending_message_ = report_exception;
 
   // Do not forget to clean catcher_ if currently thrown exception cannot
   // be caught.  If necessary, ReThrow will update the catcher.
   thread_local_top()->catcher_ = can_be_caught_externally ?
       try_catch_handler() : NULL;
 
+  // Set the exception being thrown.
   set_pending_exception(*exception_handle);
 }
 
 
 bool Isolate::HasExternalTryCatch() {
   DCHECK(has_pending_exception());
 
   return (thread_local_top()->catcher_ != NULL) &&
       (try_catch_handler() == thread_local_top()->catcher_);
 }
@@ skipping 1252 matching lines @@
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal