Teach debugger to ignore breakpoints

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 "vm/code_index_table.h"
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 290 matching lines @@
       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_index_ = desc.TokenIndex(pc_desc_index);
-  ASSERT(token_index_ > 0);
+  ASSERT(token_index_ >= 0);
   pc_ = desc.PC(pc_desc_index);
   ASSERT(pc_ != 0);
   breakpoint_kind_ = desc.DescriptorKind(pc_desc_index);
 }
 
 
 CodeBreakpoint::~CodeBreakpoint() {
   // Make sure we don't leave patched code behind.
   ASSERT(!IsEnabled());
 }
@@ skipping 86 matching lines @@
   ASSERT(!is_enabled_);
 }
 
 
 Debugger::Debugger()
     : isolate_(NULL),
       initialized_(false),
       bp_handler_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
-      resume_action_(kContinue) {
+      resume_action_(kContinue),
+      ignore_breakpoints_(false) {
 }
 
 
 Debugger::~Debugger() {
   ASSERT(src_breakpoints_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
 }
 
 
 void Debugger::Shutdown() {
@@ skipping 237 matching lines @@
                                       const String& field_name,
                                       const Instance& object) {
   const Function& getter_func =
       Function::Handle(cls.LookupGetterFunction(field_name));
   ASSERT(!getter_func.IsNull());
 
   Object& result = Object::Handle();
   LongJump* base = isolate_->long_jump_base();
   LongJump jump;
   isolate_->set_long_jump_base(&jump);
+  bool saved_ignore_flag = ignore_breakpoints_;
+  ignore_breakpoints_ = true;
   if (setjmp(*jump.Set()) == 0) {
     GrowableArray<const Object*> noArguments;
     const Array& noArgumentNames = Array::Handle();
     result = DartEntry::InvokeDynamic(object, getter_func,
                                       noArguments, noArgumentNames);
   } else {
     result = isolate_->object_store()->sticky_error();
   }
+  ignore_breakpoints_ = saved_ignore_flag;

[siva, 2012/03/10 00:11:40]

Why save and restore the flag instead of just setting it to
false here?
Do you expect recursive calls to this? I thought the goal was to avoid recursive
calls to this.

[hausner, 2012/03/10 00:41:56]

I thought it's more future-proof to allow for recursion. On the other hand,
there is probably a lot more state that would need to be saved and restored to
make the debugger truly reentrant.

For example, we might want to call the debugger when an exception is thrown,
which could happen during the evaluation of a field.

[siva, 2012/03/12 22:19:14]

Sounds like premature optimization :-)

On 2012/03/10 00:41:56, hausner wrote:

   isolate_->set_long_jump_base(base);
   return result.raw();
 }
 
 
 RawObject* Debugger::GetStaticField(const Class& cls,
                                     const String& field_name) {
   const Function& getter_func =
       Function::Handle(cls.LookupGetterFunction(field_name));
   ASSERT(!getter_func.IsNull());
 
   Object& result = Object::Handle();
   LongJump* base = isolate_->long_jump_base();
   LongJump jump;
   isolate_->set_long_jump_base(&jump);
+  bool saved_ignore_flag = ignore_breakpoints_;
+  ignore_breakpoints_ = true;
   if (setjmp(*jump.Set()) == 0) {
     GrowableArray<const Object*> noArguments;
     const Array& noArgumentNames = Array::Handle();
     result = DartEntry::InvokeStatic(getter_func, noArguments, noArgumentNames);
   } else {
     result = isolate_->object_store()->sticky_error();
   }
+  ignore_breakpoints_ = saved_ignore_flag;
   isolate_->set_long_jump_base(base);
   return result.raw();
 }
 
 
 RawArray* Debugger::GetInstanceFields(const Instance& obj) {
   Class& cls = Class::Handle(obj.clazz());
   Array& fields = Array::Handle();
   Field& field = Field::Handle();
   const GrowableObjectArray& field_list =
@@ skipping 75 matching lines @@
 void Debugger::SetBreakpointHandler(BreakpointHandler* handler) {
   bp_handler_ = handler;
   if (bp_handler_ == NULL) {
     bp_handler_ = &DefaultBreakpointHandler;
   }
 }
 
 
 void Debugger::BreakpointCallback() {
   ASSERT(initialized_);
+
+  if (ignore_breakpoints_) {
+    return;
+  }
   DartFrameIterator iterator;
   DartFrame* frame = iterator.NextFrame();
   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());
+              bpt->IsInternal() ? "hit internal" : "hit user",
+              bpt ? String::Handle(bpt->SourceUrl()).ToCString() : "?",
+              bpt ? bpt->LineNumber() : 0,
+              frame->pc());
   }
   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();
   }
@@ skipping 188 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart