Make breakpoints on == fire reliably

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 565 matching lines @@
   OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
   return chars;
 }
 
 
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   trace_.Add(frame);
 }
 
 
+static bool IsSafePoint(PcDescriptors::Kind kind) {
+  return ((kind == PcDescriptors::kIcCall) ||
+          (kind == PcDescriptors::kFuncCall) ||
+          (kind == PcDescriptors::kClosureCall) ||
+          (kind == PcDescriptors::kReturn) ||
+          (kind == PcDescriptors::kEqualNull));
+}
+
+
 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),
       src_bpt_(NULL),
       next_(NULL) {
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   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));
+  ASSERT(IsSafePoint(breakpoint_kind_));
 }
 
 
 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();
   pc_ = 0ul;
@@ skipping 50 matching lines @@
     }
     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::kEqualNull: {
+      const Code& code =
+          Code::Handle(Function::Handle(function_).unoptimized_code());
+      saved_bytes_.target_address_ =
+          CodePatcher::GetStaticCallTargetAt(pc_, code);
+      CodePatcher::PatchStaticCallAt(pc_, code,
+                                     StubCode::BreakpointEqNullEntryPoint());
+      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::kClosureCall: {
+    case PcDescriptors::kClosureCall:
+    case PcDescriptors::kEqualNull: {
       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 143 matching lines @@
         ASSERT(!function.IsNull());
         if (function.HasOptimizedCode()) {
           function.SwitchToUnoptimizedCode();
         }
       }
     }
   }
 }
 
 
-static bool IsSafePoint(PcDescriptors::Kind kind) {
-  return ((kind == PcDescriptors::kIcCall) ||
-          (kind == PcDescriptors::kFuncCall) ||
-          (kind == PcDescriptors::kClosureCall) ||
-          (kind == PcDescriptors::kReturn));
-}
-
-
 void Debugger::InstrumentForStepping(const Function& target_function) {
   if (!target_function.HasCode()) {
     Compiler::CompileFunction(target_function);
     // If there were any errors, ignore them silently and return without
     // adding breakpoints to target.
     if (!target_function.HasCode()) {
       return;
     }
   }
   DeoptimizeWorld();
@@ skipping 727 matching lines @@
       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));
+          Function& closure_func =
+              Function::Handle(Closure::function(Instance::Cast(receiver)));
+          if (IsDebuggable(closure_func)) {
+            func_to_instrument = closure_func.raw();
+          }
         }
         // 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 if (bpt->breakpoint_kind_ == PcDescriptors::kEqualNull) {
+      // This is just a call to the runtime, not Dart code. Stepping
+      // into not possible, just treat like StepOver.
+      func_to_instrument = bpt->function();
     } 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 191 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart