Implement breakpoint for closure calls

runtime/vm/debugger.cc

 // 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 "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 585 matching lines @@
   ASSERT(!code.IsNull());  // Function must be compiled.
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(pc_desc_index < desc.Length());
   token_pos_ = desc.TokenPos(pc_desc_index);
   ASSERT(token_pos_ >= 0);
   pc_ = desc.PC(pc_desc_index);
   ASSERT(pc_ != 0);
   breakpoint_kind_ = desc.DescriptorKind(pc_desc_index);
   ASSERT((breakpoint_kind_ == PcDescriptors::kIcCall) ||
          (breakpoint_kind_ == PcDescriptors::kFuncCall) ||
+         (breakpoint_kind_ == PcDescriptors::kClosureCall) ||
          (breakpoint_kind_ == PcDescriptors::kReturn));
 }
 
 
 CodeBreakpoint::~CodeBreakpoint() {
   // Make sure we don't leave patched code behind.
   ASSERT(!IsEnabled());
   // Poison the data so we catch use after free errors.
 #ifdef DEBUG
   function_ = Function::null();
@@ skipping 42 matching lines @@
     }
     case PcDescriptors::kFuncCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       saved_bytes_.target_address_ =
           CodePatcher::GetStaticCallTargetAt(pc_, code);
       CodePatcher::PatchStaticCallAt(pc_, code,
                                      StubCode::BreakpointStaticEntryPoint());
       break;
     }
+    case PcDescriptors::kClosureCall: {
+      const Code& code =
+          Code::Handle(Function::Handle(function_).unoptimized_code());
+      saved_bytes_.target_address_ =
+          CodePatcher::GetStaticCallTargetAt(pc_, code);
+      CodePatcher::PatchStaticCallAt(pc_, code,
+                                     StubCode::BreakpointClosureEntryPoint());
+      break;
+    }
     case PcDescriptors::kReturn:
       PatchFunctionReturn();
       break;
     default:
       UNREACHABLE();
   }
   is_enabled_ = true;
 }
 
 
 void CodeBreakpoint::RestoreCode() {
   ASSERT(is_enabled_);
   switch (breakpoint_kind_) {
     case PcDescriptors::kIcCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       CodePatcher::PatchInstanceCallAt(pc_, code,
                                        saved_bytes_.target_address_);
       break;
     }
-    case PcDescriptors::kFuncCall: {
+    case PcDescriptors::kFuncCall:
+    case PcDescriptors::kClosureCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       CodePatcher::PatchStaticCallAt(pc_, code,
                                      saved_bytes_.target_address_);
       break;
     }
     case PcDescriptors::kReturn:
       RestoreFunctionReturn();
       break;
     default:
@@ skipping 168 matching lines @@
     CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
     if (bpt != NULL) {
       // There is already a breakpoint for this address. Make sure
       // it is enabled.
       bpt->Enable();
       continue;
     }
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     if ((kind == PcDescriptors::kIcCall) ||
         (kind == PcDescriptors::kFuncCall) ||
+        (kind == PcDescriptors::kClosureCall) ||
         (kind == PcDescriptors::kReturn)) {
       bpt = new CodeBreakpoint(target_function, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
@@ skipping 147 matching lines @@
   intptr_t lowest_pc_index = -1;
   for (int i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenPos(i);
     ASSERT(desc_token_pos >= 0);
     if (desc_token_pos < first_token_pos) {
       continue;
     }
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     if ((kind == PcDescriptors::kIcCall) ||
         (kind == PcDescriptors::kFuncCall) ||
+        (kind == PcDescriptors::kClosureCall) ||
         (kind == PcDescriptors::kReturn)) {
       if ((desc_token_pos - first_token_pos) < best_fit) {
         best_fit = desc_token_pos - first_token_pos;
         ASSERT(best_fit >= 0);
         best_fit_index = i;
       }
       if ((first_token_pos <= desc_token_pos) &&
           (desc_token_pos <= last_token_pos) &&
           (desc.PC(i) < lowest_pc)) {
         lowest_pc = desc.PC(i);
@@ skipping 512 matching lines @@
       }
     } else if (bpt->breakpoint_kind_ == PcDescriptors::kFuncCall) {
       func_to_instrument = bpt->function();
       const Code& code = Code::Handle(func_to_instrument.CurrentCode());
       const Function& callee =
           Function::Handle(code.GetStaticCallTargetFunctionAt(bpt->pc_));
       ASSERT(!callee.IsNull());
       if (IsDebuggable(callee)) {
         func_to_instrument = callee.raw();
       }
+    } else if (bpt->breakpoint_kind_ == PcDescriptors::kClosureCall) {
+      func_to_instrument = bpt->function();
+      const Code& code = Code::Handle(func_to_instrument.CurrentCode());
+      ArgumentsDescriptor args_desc(Array::Handle(
+          CodePatcher::GetClosureArgDescAt(bpt->pc_, code)));
+      ActivationFrame* top_frame = stack_trace->ActivationFrameAt(0);
+      const Object& receiver =
+          Object::Handle(top_frame->GetClosureObject(args_desc.Count()));
+      if (!receiver.IsNull()) {
+        // Verify that the class of receiver is a closure class
+        // by checking that signature_function() is not null.
+        const Class& receiver_class = Class::Handle(receiver.clazz());
+        if (receiver_class.IsSignatureClass()) {
+          func_to_instrument = Closure::function(Instance::Cast(receiver));
+        }
+        // If the receiver is not a closure, then the runtime will attempt
+        // to invoke the "call" method on the object if one exists.
+        // TODO(hausner): find call method and intrument it for stepping.
+      }
     } else {
       ASSERT(bpt->breakpoint_kind_ == PcDescriptors::kReturn);
       // Treat like stepping out to caller.
       if (stack_trace->Length() > 1) {
         ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
         func_to_instrument = caller_frame->function().raw();
       }
     }
   } else {
     ASSERT(resume_action_ == kStepOut);
@@ skipping 193 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart