Implement deletion of breakpoints

runtime/vm/debugger.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 static const bool verbose = false;
 
 Breakpoint::Breakpoint(const Function& func, intptr_t pc_desc_index)
     : function_(func.raw()),
       pc_desc_index_(pc_desc_index),
       pc_(0),
+      saved_bytes_(0),
       line_number_(-1),
       next_(NULL) {
   Code& code = Code::Handle(func.code());
   ASSERT(!code.IsNull());  // Function must be compiled.
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(pc_desc_index < desc.Length());
   this->token_index_ = desc.TokenIndex(pc_desc_index);
   ASSERT(this->token_index_ > 0);
   this->pc_ = desc.PC(pc_desc_index);
   ASSERT(this->pc_ != 0);
@@ skipping 185 matching lines @@
 }
 
 
 Debugger::Debugger()
     : initialized_(false),
       bp_handler_(NULL),
       breakpoints_(NULL) {
 }
 
 
+Debugger::~Debugger() {
+  ASSERT(breakpoints_ == NULL);
+}
+
+
+void Debugger::Shutdown() {
+  while (breakpoints_ != NULL) {
+    Breakpoint* bpt = breakpoints_;
+    breakpoints_ = breakpoints_->next();
+    UnsetBreakpoint(bpt);
+    delete bpt;
+  }
+}
+
+
 bool Debugger::IsActive() {
   // TODO(hausner): The code generator uses this function to prevent
   // generation of optimized code when Dart code is being debugged.
   // This is probably not conservative enough (we could set the first
   // breakpoint after optimized code has already been produced).
   // Long-term, we need to be able to de-optimize code.
   return breakpoints_ != NULL;
 }
 
 
@@ skipping 24 matching lines @@
   if (!cls.IsNull()) {
     function = cls.LookupStaticFunction(function_name);
     if (function.IsNull()) {
       function = cls.LookupDynamicFunction(function_name);
     }
   }
   return function.raw();
 }
 
 
-// TODO(hausner): Need to check whether a breakpoint for the
-// location already exists and either return the existing breakpoint
-// or return an error.
+// TODO(hausner): Distinguish between newly created breakpoints and
+// returning a breakpoint that already exists?
 Breakpoint* Debugger::SetBreakpoint(const Function& target_function,
                                     intptr_t token_index) {
   if ((token_index < target_function.token_index()) ||
       (target_function.end_token_index() <= token_index)) {
     // The given token position is not within the target function.
     return NULL;
   }
   if (!target_function.HasCode()) {
     Compiler::CompileFunction(target_function);
   }
   Code& code = Code::Handle(target_function.code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   for (int i = 0; i < desc.Length(); i++) {
     if (desc.TokenIndex(i) < token_index) {
       continue;
     }
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     Breakpoint* bpt = NULL;
     if (kind == PcDescriptors::kIcCall) {
+      bpt = GetBreakpoint(desc.PC(i));
+      if (bpt != NULL) {
+        // There is an existing breakpoint at this token position.
+        break;
+      }
+      bpt = new Breakpoint(target_function, i);
+      String& func_name = String::Handle();
+      int num_args, num_named_args;
+      CodePatcher::GetInstanceCallAt(desc.PC(i),
+          &func_name, &num_args, &num_named_args, &bpt->saved_bytes_);
       CodePatcher::PatchInstanceCallAt(
           desc.PC(i), StubCode::BreakpointDynamicEntryPoint());
-      bpt = new Breakpoint(target_function, i);
+      RegisterBreakpoint(bpt);
     } else if (kind == PcDescriptors::kOther) {
       if ((desc.TokenIndex(i) > 0) && CodePatcher::IsDartCall(desc.PC(i))) {
+        bpt = GetBreakpoint(desc.PC(i));
+        if (bpt != NULL) {
+          // There is an existing breakpoint at this token position.
+          break;
+        }
+        bpt = new Breakpoint(target_function, i);
+        Function& func = Function::Handle();
+        CodePatcher::GetStaticCallAt(desc.PC(i), &func, &bpt->saved_bytes_);
         CodePatcher::PatchStaticCallAt(
           desc.PC(i), StubCode::BreakpointStaticEntryPoint());
-        bpt = new Breakpoint(target_function, i);
+        RegisterBreakpoint(bpt);
       }
     }
     if (bpt != NULL) {
       if (verbose) {
         OS::Print("Setting breakpoint at '%s' line %d  (PC %p)\n",
                   String::Handle(bpt->SourceUrl()).ToCString(),
                   bpt->LineNumber(),
                   bpt->pc());
       }
-      AddBreakpoint(bpt);
       return bpt;
     }
   }
   return NULL;
 }
 
 
+void Debugger::UnsetBreakpoint(Breakpoint* bpt) {
+  const Function& func = Function::Handle(bpt->function());
+  const Code& code = Code::Handle(func.code());
+  PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
+  intptr_t desc_index = bpt->pc_desc_index();
+  ASSERT(desc_index < desc.Length());
+  ASSERT(bpt->pc() == desc.PC(desc_index));
+  PcDescriptors::Kind kind = desc.DescriptorKind(desc_index);
+  if (kind == PcDescriptors::kIcCall) {
+    CodePatcher::PatchInstanceCallAt(desc.PC(desc_index), bpt->saved_bytes_);
+  } else {
+    CodePatcher::PatchStaticCallAt(desc.PC(desc_index), bpt->saved_bytes_);
+  }
+}
+
+
 Breakpoint* Debugger::SetBreakpointAtEntry(const Function& target_function) {
   ASSERT(!target_function.IsNull());
   return SetBreakpoint(target_function, target_function.token_index());
 }
 
 
 Breakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
                                           intptr_t line_number) {
   Library& lib = Library::Handle();
   Script& script = Script::Handle();
@@ skipping 103 matching lines @@
   while (bpt != NULL) {
     if (bpt->pc() == breakpoint_address) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
-void Debugger::AddBreakpoint(Breakpoint* bpt) {
+void Debugger::RemoveBreakpoint(Breakpoint* bpt) {
+  ASSERT(breakpoints_ != NULL);
+  Breakpoint* prev_bpt = NULL;
+  Breakpoint* curr_bpt = breakpoints_;
+  while (curr_bpt != NULL) {
+    if (bpt == curr_bpt) {
+      if (prev_bpt == NULL) {
+        breakpoints_ = breakpoints_->next();
+      } else {
+        prev_bpt->set_next(curr_bpt->next());
+      }
+      UnsetBreakpoint(bpt);
+      delete bpt;
+      return;
+    }
+    prev_bpt = curr_bpt;
+    curr_bpt = curr_bpt->next();
+  }
+  // bpt is not a registered breakpoint, nothing to do.
+}
+
+
+Breakpoint* Debugger::GetBreakpointByFunction(const Function& func,
+                                              intptr_t token_index) {
+  Breakpoint* bpt = this->breakpoints_;
+  while (bpt != NULL) {
+    if ((bpt->function() == func.raw()) &&
+        (bpt->token_index() == token_index)) {
+      return bpt;
+    }
+    bpt = bpt->next();
+  }
+  return NULL;
+}
+
+
+void Debugger::RegisterBreakpoint(Breakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(this->breakpoints_);
   this->breakpoints_ = bpt;
 }
 
 
 }  // namespace dart