Support breakpoints in closures

runtime/vm/debugger.cc

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2012, 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_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 269 matching lines @@
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, func_name, url.ToCString(), line);
   len++;  // String terminator.
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
   return chars;
 }
 
 
-void StackTrace::AddActivation(ActivationFrame* frame) {
+void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   trace_.Add(frame);
 }
 
 
 CodeBreakpoint::CodeBreakpoint(const Function& func, intptr_t pc_desc_index)
     : function_(func.raw()),
       pc_desc_index_(pc_desc_index),
       pc_(0),
       line_number_(-1),
       is_enabled_(false),
@@ skipping 205 matching lines @@
         (kind == PcDescriptors::kFuncCall) ||
         (kind == PcDescriptors::kReturn)) {
       bpt = new CodeBreakpoint(target_function, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
-CodeBreakpoint* Debugger::MakeCodeBreakpoint(SourceBreakpoint* src_bpt) {
-  Function& func = Function::Handle(src_bpt->function());
+CodeBreakpoint* Debugger::MakeCodeBreakpoint(const Function& func,
+                                             intptr_t token_index) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
-  intptr_t requested_token_index = src_bpt->token_index();
   for (int i = 0; i < desc.Length(); i++) {
-    if (desc.TokenIndex(i) < requested_token_index) {
+    if (desc.TokenIndex(i) < token_index) {
       continue;
     }
     CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
     // We should only ever have one code breakpoint at the same address.
     // If we find an existing breakpoint, it must be an internal one which
     // is used for stepping.
     if (bpt != NULL) {
       ASSERT(bpt->src_bpt() == NULL);
-      bpt->set_src_bpt(src_bpt);
       return bpt;
     }
 
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     if ((kind == PcDescriptors::kIcCall) ||
         (kind == PcDescriptors::kFuncCall) ||
         (kind == PcDescriptors::kReturn)) {
       bpt = new CodeBreakpoint(func, i);
-      bpt->set_src_bpt(src_bpt);
       if (verbose) {
         OS::Print("Setting breakpoint in function '%s' (%s:%d)  (PC %p)\n",
                   String::Handle(func.name()).ToCString(),
                   String::Handle(bpt->SourceUrl()).ToCString(),
                   bpt->LineNumber(),
                   bpt->pc());
       }
       RegisterCodeBreakpoint(bpt);
       return bpt;
     }
@@ skipping 18 matching lines @@
   RegisterSourceBreakpoint(bpt);
   if (verbose && !target_function.HasCode()) {
     OS::Print("Registering breakpoint for uncompiled function '%s'"
               " (%s:%d)\n",
               String::Handle(target_function.name()).ToCString(),
               String::Handle(bpt->SourceUrl()).ToCString(),
               bpt->LineNumber());
   }
 
   if (target_function.HasCode()) {
-    CodeBreakpoint* cbpt = MakeCodeBreakpoint(bpt);
-    if (cbpt == NULL) {
+    CodeBreakpoint* cbpt = MakeCodeBreakpoint(target_function, token_index);
+    if (cbpt != NULL) {
+      ASSERT(cbpt->src_bpt() == NULL);
+      cbpt->set_src_bpt(bpt);
+    } else {
       if (verbose) {
         OS::Print("Failed to set breakpoint at '%s' line %d\n",
                   String::Handle(bpt->SourceUrl()).ToCString(),
                   bpt->LineNumber());
       }
     }
   }
   bpt->Enable();
   return bpt;
 }
 
 
+// Synchronize the enabled/disabled state of all code breakpoints
+// associated with the source breakpoint bpt.
 void Debugger::SyncBreakpoint(SourceBreakpoint* bpt) {
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     if (bpt == cbpt->src_bpt()) {
       if (bpt->IsEnabled()) {
         cbpt->Enable();
       } else {
         cbpt->Disable();
       }
     }
@@ skipping 158 matching lines @@
     bpt = bpt->next();
   }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     cbpt->VisitObjectPointers(visitor);
     cbpt = cbpt->next();
   }
 }
 
 
-static void DefaultBreakpointHandler(SourceBreakpoint* bpt, StackTrace* stack) {
+static void DefaultBreakpointHandler(SourceBreakpoint* bpt,
+                                     DebuggerStackTrace* stack) {
   String& var_name = String::Handle();
   Instance& value = Instance::Handle();
   for (intptr_t i = 0; i < stack->Length(); i++) {
     ActivationFrame* frame = stack->ActivationFrameAt(i);
     OS::Print("   %d. %s\n",
               i + 1, frame->ToCString());
     intptr_t num_locals = frame->NumLocalVariables();
     for (intptr_t i = 0; i < num_locals; i++) {
       intptr_t token_pos, end_pos;
       frame->VariableAt(i, &var_name, &token_pos, &end_pos, &value);
@@ skipping 19 matching lines @@
   ASSERT(frame != NULL);
   CodeBreakpoint* bpt = GetCodeBreakpoint(frame->pc());
   ASSERT(bpt != NULL);
   if (verbose) {
     OS::Print(">>> %s breakpoint at %s:%d (Address %p)\n",
         bpt->IsInternal() ? "hit internal" : "hit user",
         bpt ? String::Handle(bpt->SourceUrl()).ToCString() : "?",
         bpt ? bpt->LineNumber() : 0,
         frame->pc());
   }
-  StackTrace* stack_trace = new StackTrace(8);
+  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   while (frame != NULL) {
     ASSERT(frame->IsValid());
     ASSERT(frame->IsDartFrame());
     ActivationFrame* activation =
         new ActivationFrame(frame->pc(), frame->fp(), frame->sp());
     stack_trace->AddActivation(activation);
     frame = iterator.NextFrame();
   }
 
   resume_action_ = kContinue;
@@ skipping 59 matching lines @@
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
   isolate_ = isolate;
   initialized_ = true;
   SetBreakpointHandler(DefaultBreakpointHandler);
 }
 
 
-// TODO(hausner): handle closure functions.
 void Debugger::NotifyCompilation(const Function& func) {
+  if (src_breakpoints_ == NULL) {
+    // Return with minimal overhead if there are no breakpoints.
+    return;
+  }
+  Function& lookup_function = Function::Handle(func.raw());
+  if (func.IsClosureFunction()) {
+    // If the newly compiled function is a closure, we need to use
+    // the closure's parent function to see whether there are any
+    // breakpoints.
+    lookup_function = func.parent_function();
+  }
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
-    if (func.raw() == bpt->function()) {
+    if (lookup_function.raw() == bpt->function()) {
       if (verbose) {
         OS::Print("Enable latent breakpoint for function '%s'\n",
-                  String::Handle(func.name()).ToCString());
+                  String::Handle(lookup_function.name()).ToCString());
       }
-      MakeCodeBreakpoint(bpt);
+      // Set breakpoint in newly compiled code of function func.
+      CodeBreakpoint* cbpt = MakeCodeBreakpoint(func, bpt->token_index());
+      if (cbpt != NULL) {
+        cbpt->set_src_bpt(bpt);
+      }
       bpt->Enable();  // Enables the code breakpoint as well.
     }
     bpt = bpt->next();
   }
 }
 
 
 CodeBreakpoint* Debugger::GetCodeBreakpoint(uword breakpoint_address) {
   CodeBreakpoint* bpt = code_breakpoints_;
   while (bpt != NULL) {
@@ skipping 83 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart