Make the debugger completely unload when the debug event listener is unregist...

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 296 matching lines @@
     ClearDebugBreakAtReturn();
   } else {
     // Patch the code to the original invoke.
     rinfo()->set_target_address(original_rinfo()->target_address());
   }
   ASSERT(!IsDebugBreak());
 }
 
 
 void BreakLocationIterator::PrepareStepIn() {
+  HandleScope scope;
+
   // Step in can only be prepared if currently positioned on an IC call or
   // construct call.
   Address target = rinfo()->target_address();
   Code* code = Code::GetCodeFromTargetAddress(target);
   if (code->is_call_stub()) {
     // Step in through IC call is handled by the runtime system. Therefore make
     // sure that the any current IC is cleared and the runtime system is
     // called. If the executing code has a debug break at the location change
     // the call in the original code as it is the code there that will be
     // executed in place of the debug break call.
@@ skipping 29 matching lines @@
     return Debug::IsDebugBreak(rinfo()->target_address());
   }
 }
 
 
 Object* BreakLocationIterator::BreakPointObjects() {
   return debug_info_->GetBreakPointObjects(code_position());
 }
 
 
+// Clear out all the debug break code. This is ONLY supposed to be used when
+// shutting down the debugger as it will leave the break point information in
+// DebugInfo even though the code is patched back to the non break point state.
+void BreakLocationIterator::ClearAllDebugBreak() {
+  while (!Done()) {
+    ClearDebugBreak();
+    Next();
+  }
+}
+
+
 bool BreakLocationIterator::RinfoDone() const {
   ASSERT(reloc_iterator_->done() == reloc_iterator_original_->done());
   return reloc_iterator_->done();
 }
 
 
 void BreakLocationIterator::RinfoNext() {
   reloc_iterator_->next();
   reloc_iterator_original_->next();
 #ifdef DEBUG
@@ skipping 206 matching lines @@
   return true;
 }
 
 
 void Debug::Unload() {
   // Return debugger is not loaded.
   if (!IsLoaded()) {
     return;
   }
 
+  // Get rid of all break points and related information.
+  ClearAllBreakPoints();
+
   // Clear debugger context global handle.
   GlobalHandles::Destroy(reinterpret_cast<Object**>(debug_context_.location()));
   debug_context_ = Handle<Context>();
 }
 
 
 void Debug::Iterate(ObjectVisitor* v) {
   v->VisitPointer(bit_cast<Object**, Code**>(&(debug_break_return_entry_)));
   v->VisitPointer(bit_cast<Object**, Code**>(&(debug_break_return_)));
 }
@@ skipping 106 matching lines @@
   // Return undefined if no break points where triggered.
   if (break_points_hit_count == 0) {
     return Factory::undefined_value();
   }
   return break_points_hit;
 }
 
 
 // Check whether a single break point object is triggered.
 bool Debug::CheckBreakPoint(Handle<Object> break_point_object) {
+  HandleScope scope;
+
   // Ignore check if break point object is not a JSObject.
   if (!break_point_object->IsJSObject()) return true;
 
   // Get the function CheckBreakPoint (defined in debug.js).
   Handle<JSFunction> check_break_point =
     Handle<JSFunction>(JSFunction::cast(
       debug_context()->global()->GetProperty(
           *Factory::LookupAsciiSymbol("IsBreakPointTriggered"))));
 
   // Get the break id as an object.
@@ skipping 30 matching lines @@
 // prior to ensure the debug info has been generated for shared.
 Handle<DebugInfo> Debug::GetDebugInfo(Handle<SharedFunctionInfo> shared) {
   ASSERT(HasDebugInfo(shared));
   return Handle<DebugInfo>(DebugInfo::cast(shared->debug_info()));
 }
 
 
 void Debug::SetBreakPoint(Handle<SharedFunctionInfo> shared,
                           int source_position,
                           Handle<Object> break_point_object) {
+  HandleScope scope;
+
   if (!EnsureDebugInfo(shared)) {
     // Return if retrieving debug info failed.
     return;
   }
 
   Handle<DebugInfo> debug_info = GetDebugInfo(shared);
   // Source positions starts with zero.
   ASSERT(source_position >= 0);
 
   // Find the break point and change it.
   BreakLocationIterator it(debug_info, SOURCE_BREAK_LOCATIONS);
   it.FindBreakLocationFromPosition(source_position);
   it.SetBreakPoint(break_point_object);
 
   // At least one active break point now.
   ASSERT(debug_info->GetBreakPointCount() > 0);
 }
 
 
 void Debug::ClearBreakPoint(Handle<Object> break_point_object) {
+  HandleScope scope;
+
   DebugInfoListNode* node = debug_info_list_;
   while (node != NULL) {
     Object* result = DebugInfo::FindBreakPointInfo(node->debug_info(),
                                                    break_point_object);
     if (!result->IsUndefined()) {
       // Get information in the break point.
       BreakPointInfo* break_point_info = BreakPointInfo::cast(result);
       Handle<DebugInfo> debug_info = node->debug_info();
       Handle<SharedFunctionInfo> shared(debug_info->shared());
       int source_position =  break_point_info->statement_position()->value();
@@ skipping 12 matching lines @@
         RemoveDebugInfo(debug_info);
       }
 
       return;
     }
     node = node->next();
   }
 }
 
 
+void Debug::ClearAllBreakPoints() {
+  DebugInfoListNode* node = debug_info_list_;
+  while (node != NULL) {
+    // Remove all debug break code.
+    BreakLocationIterator it(node->debug_info(), ALL_BREAK_LOCATIONS);
+    it.ClearAllDebugBreak();
+    node = node->next();
+  }
+
+  // Remove all debug info.
+  while (debug_info_list_ != NULL) {
+    RemoveDebugInfo(debug_info_list_->debug_info());
+  }
+}
+
+
 void Debug::FloodWithOneShot(Handle<SharedFunctionInfo> shared) {
   // Make sure the function has setup the debug info.
   if (!EnsureDebugInfo(shared)) {
     // Return if we failed to retrieve the debug info.
     return;
   }
 
   // Flood the function with break points.
   BreakLocationIterator it(GetDebugInfo(shared), ALL_BREAK_LOCATIONS);
   while (!it.Done()) {
@@ skipping 377 matching lines @@
     }
     // Move to next in list.
     prev = current;
     current = current->next();
   }
   UNREACHABLE();
 }
 
 
 void Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
+  HandleScope scope;
+
   // Get the executing function in which the debug break occurred.
   Handle<SharedFunctionInfo> shared =
       Handle<SharedFunctionInfo>(JSFunction::cast(frame->function())->shared());
   if (!EnsureDebugInfo(shared)) {
     // Return if we failed to retrieve the debug info.
     return;
   }
   Handle<DebugInfo> debug_info = GetDebugInfo(shared);
   Handle<Code> code(debug_info->code());
   Handle<Code> original_code(debug_info->original_code());
@@ skipping 55 matching lines @@
   }
 }
 
 
 bool Debug::IsDebugGlobal(GlobalObject* global) {
   return IsLoaded() && global == Debug::debug_context()->global();
 }
 
 
 void Debug::ClearMirrorCache() {
+  HandleScope scope;
   ASSERT(Top::context() == *Debug::debug_context());
 
   // Clear the mirror cache.
   Handle<String> function_name =
       Factory::LookupSymbol(CStrVector("ClearMirrorCache"));
   Handle<Object> fun(Top::global()->GetProperty(*function_name));
   ASSERT(fun->IsJSFunction());
   bool caught_exception;
   Handle<Object> js_object = Execution::TryCall(
       Handle<JSFunction>::cast(fun),
@@ skipping 279 matching lines @@
   if (caught_exception) {
     return;
   }
   // Process debug event.
   ProcessDebugEvent(v8::NewFunction, event_data);
 }
 
 
 void Debugger::ProcessDebugEvent(v8::DebugEvent event,
                                  Handle<Object> event_data) {
+  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);
   }
@@ skipping 96 matching lines @@
 }
 
 
 void Debugger::UpdateActiveDebugger() {
   set_debugger_active((message_thread_ != NULL &&
                        debug_message_handler_ != NULL) ||
                        !event_listener_.is_null());
   if (!debugger_active() && message_thread_) {
     message_thread_->OnDebuggerInactive();
   }
+  if (!debugger_active()) {
+    Debug::Unload();
+  }
 }
 
 
 Handle<Object> Debugger::Call(Handle<JSFunction> fun,
                               Handle<Object> data,
                               bool* pending_exception) {
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter() || !debugger.HasJavaScriptFrames()) {
     return Factory::undefined_value();
@@ skipping 84 matching lines @@
     }
   }
 }
 
 
 // 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) {
+  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;
     case v8::Exception:
       interactive = true;  // Exception event is always interactive
@@ skipping 201 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal