Debugger break on TypeError, AssertionError

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_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 458 matching lines @@
       initialized_(false),
       bp_handler_(NULL),
       event_handler_(NULL),
       next_id_(1),
       stack_trace_(NULL),
       obj_cache_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       last_bpt_line_(-1),
-      ignore_breakpoints_(false) {
+      ignore_breakpoints_(false),
+      pause_on_exception_(false),
+      pause_on_unhandled_exception_(false) {
 }
 
 
 Debugger::~Debugger() {
   ASSERT(src_breakpoints_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
   ASSERT(stack_trace_ == NULL);
   ASSERT(obj_cache_ == NULL);
 }
 
@@ skipping 109 matching lines @@
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
     DebuggerEvent event;
     event.type = kBreakpointResolved;
     event.breakpoint = bpt;
     (*event_handler_)(&event);
   }
 }
 
 
+DebuggerStackTrace* Debugger::CollectStackTrace() {
+  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
+  DartFrameIterator iterator;
+  StackFrame* frame = iterator.NextFrame();
+  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();
+  }
+  return stack_trace;
+}
+
+
+// TODO(hausner): Determine whether the exception is handled or not, and
+// check with the settings the user specified to determine whether the
+// debugger should pause or not.
+// For now, we just pause on TypeError and AssertionError exceptions.
+bool Debugger::ShouldPauseOnException(DebuggerStackTrace* stack_trace,
+                                      const Object& exc) {
+  const Class& exc_class = Class::Handle(exc.clazz());
+  const String& class_name = String::Handle(exc_class.Name());
+  // TODO(hausner): Note the poor man's type test. Replace with check for
+  // actual class object or class id.
+  return class_name.Equals("TypeError") || class_name.Equals("AssertionError");

[siva, 2012/06/08 17:17:27]

There may be a use case to treat these two separately, that is somebody wants to
stop only on type errors vs somebody who wants to stop on user introduced
assertions.

[hausner, 2012/06/08 17:42:35]

That is my end goal. I think it would be nice if users could select from a list
of exceptions, or all handled or unhandled exceptions. That is for a future
checkin. What I have here is good enough for the demo that Lars wants.

On 2012/06/08 17:17:27, asiva wrote:

+}
+
+
+void Debugger::SignalExceptionThrown(const Object& exc) {
+  if (ignore_breakpoints_) {
+    return;
+  }
+  DebuggerStackTrace* stack_trace = CollectStackTrace();
+  if (!ShouldPauseOnException(stack_trace, exc)) {
+    return;
+  }
+  // No single-stepping possible after this pause event.
+  last_bpt_line_ = -1;
+  if (event_handler_ != NULL) {
+    ASSERT(stack_trace_ == NULL);
+    stack_trace_ = stack_trace;
+    ASSERT(obj_cache_ == NULL);
+    obj_cache_ = new RemoteObjectCache(64);
+    DebuggerEvent event;
+    event.type = kExceptionThrown;
+    event.exception = &exc;
+    (*event_handler_)(&event);
+    stack_trace_ = NULL;
+    obj_cache_ = NULL;  // Remote object cache is zone allocated.
+  }
+}
+
+
 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 best_fit_index = -1;
   intptr_t best_fit = INT_MAX;
   for (int i = 0; i < desc.Length(); i++) {
@@ skipping 354 matching lines @@
       (fkind == RawFunction::kImplicitSetter) ||
       (fkind == RawFunction::kConstImplicitGetter)) {
     return false;
   }
   const Class& cls = Class::Handle(func.owner());
   const Library& lib = Library::Handle(cls.library());
   return lib.IsDebuggable();
 }
 
 
-void Debugger::BreakpointCallback() {
-  ASSERT(initialized_);
-
+void Debugger::SignalBpReached() {
   if (ignore_breakpoints_) {
     return;
   }
-  DartFrameIterator iterator;
-  StackFrame* frame = iterator.NextFrame();
-  ASSERT(frame != NULL && frame->IsDartFrame());
-  CodeBreakpoint* bpt = GetCodeBreakpoint(frame->pc());
+  DebuggerStackTrace* stack_trace = CollectStackTrace();
+  ASSERT(stack_trace->Length() > 0);
+  ActivationFrame* top_frame = stack_trace->ActivationFrameAt(0);
+  ASSERT(top_frame != NULL);
+  CodeBreakpoint* bpt = GetCodeBreakpoint(top_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());
+    OS::Print(">>> hit %s breakpoint at %s:%d (Address %p)\n",
+              bpt->IsInternal() ? "internal" : "user",
+              String::Handle(bpt->SourceUrl()).ToCString(),
+              bpt->LineNumber(),
+              top_frame->pc());
   }
 
   if (!bpt->IsInternal()) {
-    // This is a user-defined breakpoint, so we call the breakpoint callback
-    // even if it is on the same line as the previous breakpoint.
+    // This is a user-defined breakpoint so we call the breakpoint
+    // callback even if it is on the same line as the previous breakpoint.
     last_bpt_line_ = -1;
   }
 
   bool notify_frontend =
     (last_bpt_line_ < 0) || (last_bpt_line_ != bpt->LineNumber());
 
-  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();
-  }
-
   if (notify_frontend) {
     resume_action_ = kContinue;
     if (bp_handler_ != NULL) {
       SourceBreakpoint* src_bpt = bpt->src_bpt();
       ASSERT(stack_trace_ == NULL);
       ASSERT(obj_cache_ == NULL);
       obj_cache_ = new RemoteObjectCache(64);
       stack_trace_ = stack_trace;
       (*bp_handler_)(src_bpt, stack_trace);
       stack_trace_ = NULL;
@@ skipping 244 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart