Added automatic debug break for processing debugger commands

src/debug.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 670 matching lines @@
 
   // Notify debugger if a real break point is triggered or if performing single
   // stepping with no more steps to perform. Otherwise do another step.
   if (!break_points_hit->IsUndefined() ||
     (thread_local_.last_step_action_ != StepNone &&
      thread_local_.step_count_ == 0)) {
     // Clear all current stepping setup.
     ClearStepping();
 
     // Notify the debug event listeners.
-    Debugger::OnDebugBreak(break_points_hit);
+    Debugger::OnDebugBreak(break_points_hit, false);
   } else if (thread_local_.last_step_action_ != StepNone) {
     // Hold on to last step action as it is cleared by the call to
     // ClearStepping.
     StepAction step_action = thread_local_.last_step_action_;
     int step_count = thread_local_.step_count_;
 
     // Clear all current stepping setup.
     ClearStepping();
 
     // Set up for the remaining steps.
@@ skipping 799 matching lines @@
   if (!caught_exception) {
     event_data = MakeExceptionEvent(exec_state, exception, uncaught,
                                     &caught_exception);
   }
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
   // Process debug event
-  ProcessDebugEvent(v8::Exception, event_data);
+  ProcessDebugEvent(v8::Exception, event_data, false);
   // Return to continue execution from where the exception was thrown.
 }
 
 
-void Debugger::OnDebugBreak(Handle<Object> break_points_hit) {
+void Debugger::OnDebugBreak(Handle<Object> break_points_hit,
+                            bool auto_continue) {
   HandleScope scope;
 
   // Debugger has already been entered by caller.
   ASSERT(Top::context() == *Debug::debug_context());
 
   // Bail out if there is no listener for this event
   if (!Debugger::EventActive(v8::Break)) return;
 
   // Debugger must be entered in advance.
   ASSERT(Top::context() == *Debug::debug_context());
 
   // Create the event data object.
   bool caught_exception = false;
   Handle<Object> exec_state = MakeExecutionState(&caught_exception);
   Handle<Object> event_data;
   if (!caught_exception) {
     event_data = MakeBreakEvent(exec_state, break_points_hit,
                                 &caught_exception);
   }
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
   // Process debug event
-  ProcessDebugEvent(v8::Break, event_data);
+  ProcessDebugEvent(v8::Break, event_data, auto_continue);
 }
 
 
 void Debugger::OnBeforeCompile(Handle<Script> script) {
   HandleScope scope;
 
   // Bail out based on state or if there is no listener for this event
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!EventActive(v8::BeforeCompile)) return;
 
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // Create the event data object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeCompileEvent(script, true, &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
   // Process debug event
-  ProcessDebugEvent(v8::BeforeCompile, event_data);
+  ProcessDebugEvent(v8::BeforeCompile, event_data, false);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debugger::OnAfterCompile(Handle<Script> script, Handle<JSFunction> fun) {
   HandleScope scope;
 
   // No compile events while compiling natives.
   if (compiling_natives()) return;
 
@@ skipping 40 matching lines @@
 
   // Create the compile state object.
   Handle<Object> event_data = MakeCompileEvent(script,
                                                false,
                                                &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
   // Process debug event
-  ProcessDebugEvent(v8::AfterCompile, event_data);
+  ProcessDebugEvent(v8::AfterCompile, event_data, false);
 }
 
 
 void Debugger::OnNewFunction(Handle<JSFunction> function) {
   return;
   HandleScope scope;
 
   // Bail out based on state or if there is no listener for this event
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!Debugger::EventActive(v8::NewFunction)) return;
 
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // Create the event object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeNewFunctionEvent(function, &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
   // Process debug event.
-  ProcessDebugEvent(v8::NewFunction, event_data);
+  ProcessDebugEvent(v8::NewFunction, event_data, false);
 }
 
 
 void Debugger::ProcessDebugEvent(v8::DebugEvent event,
-                                 Handle<Object> event_data) {
+                                 Handle<Object> event_data,
+                                 bool auto_continue) {
   HandleScope scope;
 
   // Create the execution state.
   bool caught_exception = false;
   Handle<Object> exec_state = MakeExecutionState(&caught_exception);
   if (caught_exception) {
     return;
   }
   // First notify the builtin debugger.
   if (message_thread_ != NULL) {
-    message_thread_->DebugEvent(event, exec_state, event_data);
+    message_thread_->DebugEvent(event, exec_state, event_data, auto_continue);
   }
   // Notify registered debug event listener. This can be either a C or a
   // JavaScript function.
   if (!event_listener_.is_null()) {
     if (event_listener_->IsProxy()) {
       // C debug event listener.
       Handle<Proxy> callback_obj(Handle<Proxy>::cast(event_listener_));
       v8::DebugEventCallback callback =
             FUNCTION_CAST<v8::DebugEventCallback>(callback_obj->proxy());
       callback(event,
@@ skipping 86 matching lines @@
 
 void Debugger::ProcessCommand(Vector<const uint16_t> command) {
   if (message_thread_ != NULL) {
     message_thread_->ProcessCommand(
         Vector<uint16_t>(const_cast<uint16_t *>(command.start()),
                          command.length()));
   }
 }
 
 
+bool Debugger::HasCommands() {
+  if (message_thread_ != NULL) {
+    return message_thread_->HasCommands();
+  } else {
+    return false;
+  }
+}
+
+
 void Debugger::ProcessHostDispatch(void* dispatch) {
   if (message_thread_ != NULL) {
     message_thread_->ProcessHostDispatch(dispatch);
   }
 }
 
 
 void Debugger::UpdateActiveDebugger() {
   set_debugger_active((message_thread_ != NULL &&
                        message_handler_ != NULL) ||
@@ skipping 111 matching lines @@
       Debugger::SendMessage(message);
     }
   }
 }
 
 
 // This method is called by the V8 thread whenever a debug event occurs in
 // the VM.
 void DebugMessageThread::DebugEvent(v8::DebugEvent event,
                                     Handle<Object> exec_state,
-                                    Handle<Object> event_data) {
+                                    Handle<Object> event_data,
+                                    bool auto_continue) {
   HandleScope scope;
 
   if (!Debug::Load()) return;
 
   // Process the individual events.
   bool interactive = false;
   switch (event) {
     case v8::Break:
       interactive = true;  // Break event is always interactive
       break;
@@ skipping 22 matching lines @@
       v8::Function::Cast(*api_exec_state->Get(fun_name));
   v8::TryCatch try_catch;
   v8::Local<v8::Object> cmd_processor =
       v8::Object::Cast(*fun->Call(api_exec_state, 0, NULL));
   if (try_catch.HasCaught()) {
     PrintLn(try_catch.Exception());
     return;
   }
 
   // Notify the debugger that a debug event has occurred.
-  bool success = SetEventJSONFromEvent(event_data);
-  if (!success) {
-    // If failed to notify debugger just continue running.
-    return;
+  if (!auto_continue) {
+    bool success = SetEventJSONFromEvent(event_data);
+    if (!success) {
+      // If failed to notify debugger just continue running.
+      return;
+    }
   }
 
-  // Wait for requests from the debugger.
+  // Process requests from the debugger.
   host_running_ = false;
   while (true) {
+    // Wait for new command in the queue.
     command_received_->Wait();
+
+    // The debug command interrupt flag might have been set when the command was
+    // added.
+    StackGuard::Continue(DEBUGCOMMAND);
+
+    // Get the command from the queue.
+    Vector<uint16_t> command = command_queue_.Get();
     Logger::DebugTag("Got request from command queue, in interactive loop.");
-    Vector<uint16_t> command = command_queue_.Get();
     ASSERT(!host_running_);
     if (!Debugger::debugger_active()) {
       host_running_ = true;
       return;
     }
 
     // Check if the command is a host dispatch.
     if (command[0] == 0) {
       if (Debugger::host_dispatch_handler_) {
         int32_t dispatch = (command[1] << 16) | command[2];
@@ skipping 52 matching lines @@
     Vector<uint16_t> str(reinterpret_cast<uint16_t*>(*val),
                         response->Length());
 
     // Set host_running_ correctly for nested debugger evaluations.
     host_running_ = running;
 
     // Return the result.
     SendMessage(str);
 
     // Return from debug event processing is VM should be running.
-    if (running) {
+    if (running || (auto_continue && !HasCommands())) {
       return;
     }
   }
 }
 
 
 // Puts a command coming from the public API on the queue.  Creates
 // a copy of the command string managed by the debugger.  Up to this
 // point, the command data was managed by the API client.  Called
 // by the API client thread.  This is where the API client hands off
 // processing of the command to the DebugMessageThread thread.
 // The new copy of the command is destroyed in HandleCommand().
 void DebugMessageThread::ProcessCommand(Vector<uint16_t> command) {
   Vector<uint16_t> command_copy = command.Clone();
   Logger::DebugTag("Put command on command_queue.");
   command_queue_.Put(command_copy);
   command_received_->Signal();
+
+  if (!Debug::InDebugger()) {
+    StackGuard::DebugCommand();
+  }
 }
 
 
 // Puts a host dispatch comming from the public API on the queue.
 void DebugMessageThread::ProcessHostDispatch(void* dispatch) {
   uint16_t hack[3];
   hack[0] = 0;
   hack[1] = reinterpret_cast<uint32_t>(dispatch) >> 16;
   hack[2] = reinterpret_cast<uint32_t>(dispatch) & 0xFFFF;
   Logger::DebugTag("Put dispatch on command_queue.");
@@ skipping 81 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal