Trigger exception debug event for promises at the throw site.

src/debug.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 "v8.h"
 
 #include "api.h"
 #include "arguments.h"
 #include "bootstrapper.h"
 #include "code-stubs.h"
@@ skipping 19 matching lines @@
 namespace v8 {
 namespace internal {
 
 Debug::Debug(Isolate* isolate)
     : has_break_points_(false),
       script_cache_(NULL),
       debug_info_list_(NULL),
       disable_break_(false),
       break_on_exception_(false),
       break_on_uncaught_exception_(false),
+      current_promise_catch_handler_(NULL),
       debug_break_return_(NULL),
       debug_break_slot_(NULL),
       isolate_(isolate) {
   memset(registers_, 0, sizeof(JSCallerSavedBuffer));
 }
 
 
 Debug::~Debug() {
 }
 
@@ skipping 1260 matching lines @@
 
 bool Debug::IsBreakOnException(ExceptionBreakType type) {
   if (type == BreakUncaughtException) {
     return break_on_uncaught_exception_;
   } else {
     return break_on_exception_;
   }
 }
 
 
+void Debug::PromiseHandlePrologue(Handle<JSFunction> promise_getter) {
+  Handle<Object> current_promise_getter;
+  if (current_promise_getter_.ToHandle(&current_promise_getter)) {
+    isolate_->global_handles()->Destroy(current_promise_getter.location());
+  }
+  current_promise_getter_ = Handle<JSFunction>::cast(
+      isolate_->global_handles()->Create(*promise_getter));
+  current_promise_catch_handler_ =
+      StackHandler::FromAddress(Isolate::handler(isolate_->thread_local_top()));
+}
+
+
+void Debug::PromiseHandleEpilogue() {
+  current_promise_catch_handler_ = NULL;

[rossberg, 2014/04/30 12:55:17]

Are we sure that PromiseHandle can never be reentered recursively?

[Yang, 2014/04/30 13:20:14]

I'm asserting now that the prologue always gets the uninitialized state.

+  Handle<Object> promise_getter;
+  if (!current_promise_getter_.ToHandle(&promise_getter)) return;
+  isolate_->global_handles()->Destroy(promise_getter.location());
+  current_promise_getter_ = MaybeHandle<JSFunction>();
+}
+
+
+Handle<Object> Debug::GetPromiseForUncaughtException() {
+  Handle<JSFunction> promise_getter;
+  Handle<Object> undefined = isolate_->factory()->undefined_value();
+  if (current_promise_getter_.ToHandle(&promise_getter)) {
+    // Find the top-most try-catch handler.
+    StackHandler* handler = StackHandler::FromAddress(
+        Isolate::handler(isolate_->thread_local_top()));
+    while (handler != NULL && !handler->is_catch()) {
+      handler = handler->next();
+    }
+#ifdef DEBUG
+    // Make sure that our promise catch handler is in the list of handlers,
+    // even if it's not the top-most try-catch handler.
+    StackHandler* temp = handler;
+    while (temp != current_promise_catch_handler_ && !temp->is_catch()) {
+      temp = temp->next();
+      CHECK(temp != NULL);
+    }
+#endif  // DEBUG
+
+    if (handler == current_promise_catch_handler_) {
+      return Execution::Call(
+          isolate_, promise_getter, undefined, 0, NULL).ToHandleChecked();
+    }
+  }
+  return undefined;
+}
+
+
 void Debug::PrepareStep(StepAction step_action,
                         int step_count,
                         StackFrame::Id frame_id) {
   HandleScope scope(isolate_);
 
   PrepareForBreakPoints();
 
   ASSERT(Debug::InDebugger());
 
   // Remember this step action and count.
@@ skipping 1303 matching lines @@
   if (!MakeExecutionState().ToHandle(&exec_state)) return MaybeHandle<Object>();
   // Create the script collected event object.
   Handle<Object> id_object = Handle<Smi>(Smi::FromInt(id), isolate_);
   Handle<Object> argv[] = { exec_state, id_object };
 
   return MakeJSObject(
       CStrVector("MakeScriptCollectedEvent"), ARRAY_SIZE(argv), argv);
 }
 
 
-void Debugger::OnException(Handle<Object> exception,
-                           bool uncaught,
-                           Handle<Object> promise) {
+void Debugger::OnException(Handle<Object> exception, bool uncaught) {
   HandleScope scope(isolate_);
   Debug* debug = isolate_->debug();
 
   // Bail out based on state or if there is no listener for this event
   if (debug->InDebugger()) return;
   if (!Debugger::EventActive(v8::Exception)) return;
 
+  Handle<Object> promise = debug->GetPromiseForUncaughtException();
+  uncaught |= !promise->IsUndefined();
+
   // Bail out if exception breaks are not active
   if (uncaught) {
     // Uncaught exceptions are reported by either flags.
     if (!(debug->break_on_uncaught_exception() ||
           debug->break_on_exception())) return;
   } else {
     // Caught exceptions are reported is activated.
     if (!debug->break_on_exception()) return;
   }
 
   // Enter the debugger.
   EnterDebugger debugger(isolate_);
   if (debugger.FailedToEnter()) return;
 
   // Clear all current stepping setup.
   debug->ClearStepping();
 
-  // Determine event;
-  DebugEvent event = promise->IsUndefined()
-      ? v8::Exception : v8::PendingExceptionInPromise;
-
   // Create the event data object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
   if (!MakeExceptionEvent(
           exception, uncaught, promise).ToHandle(&event_data)) {
     return;
   }
 
   // Process debug event.
-  ProcessDebugEvent(event, Handle<JSObject>::cast(event_data), false);
+  ProcessDebugEvent(v8::Exception, Handle<JSObject>::cast(event_data), false);
   // Return to continue execution from where the exception was thrown.
 }
 
 
 void Debugger::OnDebugBreak(Handle<Object> break_points_hit,
                             bool auto_continue) {
   HandleScope scope(isolate_);
 
   // Debugger has already been entered by caller.
   ASSERT(isolate_->context() == *isolate_->debug()->debug_context());
@@ skipping 461 matching lines @@
     // Send an empty command to the debugger if in a break to make JavaScript
     // run again if the debugger is closed.
     if (isolate_->debug()->InDebugger()) {
       ProcessCommand(Vector<const uint16_t>::empty());
     }
   }
 }
 
 
 void Debugger::ListenersChanged() {
-  if (IsDebuggerActive()) {
+  bool active = IsDebuggerActive();
+  if (active) {
     // Disable the compilation cache when the debugger is active.
     isolate_->compilation_cache()->Disable();
     debugger_unload_pending_ = false;
   } else {
     isolate_->compilation_cache()->Enable();
     // Unload the debugger if event listener and message handler cleared.
     // Schedule this for later, because we may be in non-V8 thread.
     debugger_unload_pending_ = true;
   }
 }
@@ skipping 544 matching lines @@
       already_signalled_ = false;
     }
     {
       Locker locker(reinterpret_cast<v8::Isolate*>(isolate_));
       isolate_->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 } }  // namespace v8::internal