Check whether exceptions are caught

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 283 matching lines @@
 
 intptr_t ActivationFrame::PcDescIndex() {
   if (pc_desc_index_ < 0) {
     TokenPos();
     ASSERT(pc_desc_index_ >= 0);
   }
   return pc_desc_index_;
 }
 
 
+intptr_t ActivationFrame::TryIndex() {
+  intptr_t desc_index = PcDescIndex();
+  return pc_desc_.TryIndex(desc_index);
+}
+
+
 intptr_t ActivationFrame::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceScript());
     intptr_t ignore_column;
     script.GetTokenLocation(TokenPos(), &line_number_, &ignore_column);
   }
   return line_number_;
 }
 
@@ skipping 51 matching lines @@
     var_descriptors_.GetInfo(i, &var_info);
     if (var_info.kind == RawLocalVarDescriptors::kContextChain) {
       return reinterpret_cast<RawContext*>(GetLocalVarValue(var_info.index));
     }
   }
   // Caller uses same context chain.
   return ctx_.raw();
 }
 
 
+// TODO(hausner): Eliminate this helper function by sorting the
+// ExceptionHandlers entries by try_index and eliminating
+// the try_index field altogether.
+static intptr_t FindTryIndex(const ExceptionHandlers& handlers,
+                             intptr_t try_index) {
+  intptr_t len = handlers.Length();
+  for (int i = 0; i < len; i++) {
+    if (handlers.TryIndex(i) == try_index) return i;
+  }
+  UNREACHABLE();
+  return -1;
+}
+
+
+ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
+    const Instance& exc_obj) const {
+  ExceptionHandlers& handlers = ExceptionHandlers::Handle();
+  Array& handled_types = Array::Handle();
+  Type& type = Type::Handle();
+  const TypeArguments& no_instantiator = TypeArguments::Handle();
+  for (int frame_index = 0; frame_index < Length(); frame_index++) {
+    ActivationFrame* frame = trace_[frame_index];
+    intptr_t try_index = frame->TryIndex();
+    if (try_index < 0) continue;
+    const Code& code = frame->DartCode();
+    handlers = code.exception_handlers();
+    ASSERT(!handlers.IsNull());
+    intptr_t num_handlers_checked = 0;
+    while (try_index >= 0) {
+      intptr_t i = FindTryIndex(handlers, try_index);
+      // Detect circles in the exception handler data.
+      num_handlers_checked++;
+      ASSERT(num_handlers_checked <= handlers.Length());
+      handled_types = handlers.GetHandledTypes(i);
+      intptr_t num_types = handled_types.Length();

[srdjan, 2013/01/16 21:12:16]

const

[hausner, 2013/01/16 22:07:25]

Done.

+      for (int k = 0; k < num_types; k++) {
+        type ^= handled_types.At(k);
+        ASSERT(!type.IsNull());
+        if (type.IsDynamicType()) return frame;
+        if (type.IsMalformed()) continue;

[regis, 2013/01/16 21:06:36]

If the type is malformed, the test at run time will always throw a TypeError. In
other words, this frame handles the exception, even so briefly. Is 'continue'
correct?

[hausner, 2013/01/16 22:07:25]

I think 'continue' to the next type check is correct. This type check will not
succeed when the Dart catch clause executes it later. The TypeError that will be
thrown is intercepted again by the debugger.

+        if (exc_obj.IsInstanceOf(type, no_instantiator, NULL)) {

[regis, 2013/01/16 21:06:36]

How about a comment indicating you may get a false positive without
instantiator?
Actually, I see in the parser that you filter out uninstantiated types. Maybe
you could assert that here or write a comment that it is the case.

[hausner, 2013/01/16 22:07:25]

Done.

+          return frame;
+        }
+      }
+      try_index = handlers.OuterTryIndex(i);
+    }
+  }
+  return NULL;
+}
+
+
 void ActivationFrame::GetDescIndices() {
   if (vars_initialized_) {
     return;
   }
   GetVarDescriptors();
 
   // We don't trust variable descriptors in optimized code.
   // Rather than potentially displaying incorrect values, we
   // pretend that there are no variables in the frame.
   // We should be more clever about this in the future.
@@ skipping 474 matching lines @@
          (pause_info == kPauseOnAllExceptions));
   exc_pause_info_ = pause_info;
 }
 
 
 Dart_ExceptionPauseInfo Debugger::GetExceptionPauseInfo() {
   return (Dart_ExceptionPauseInfo)exc_pause_info_;
 }
 
 
-// TODO(hausner): Determine whether the exception is handled or not.
 bool Debugger::ShouldPauseOnException(DebuggerStackTrace* stack_trace,
-                                      const Object& exc) {
+                                      const Instance& exc) {
   if (exc_pause_info_ == kNoPauseOnExceptions) {
     return false;
   }
-  if ((exc_pause_info_ & kPauseOnAllExceptions) != 0) {
+  if (exc_pause_info_ == kPauseOnAllExceptions) {
     return true;
   }
-  // Assume TypeError and AssertionError exceptions are unhandled.
-  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. This code will go
-  // away when we have a way to determine whether an exception is unhandled.
-  if (class_name.Equals("TypeErrorImplementation")) {
-    return true;
-  }
-  if (class_name.Equals("AssertionErrorImplementation")) {
+  ASSERT(exc_pause_info_ == kPauseOnUnhandledExceptions);
+  ActivationFrame* handler_frame = stack_trace->GetHandlerFrame(exc);
+  if (handler_frame == NULL) {
+    // Did not find an exception handler that catches this exception.
+    // Note that this check is not precise, since we can't check
+    // uninstantiated types, i.e. types containing type parameters.
+    // Thus, we may report an exception as unhandled when in fact
+    // it will be caught once we unwind the stack.
     return true;
   }
   return false;
 }
 
 
-void Debugger::SignalExceptionThrown(const Object& exc) {
+void Debugger::SignalExceptionThrown(const Instance& exc) {
   // We ignore this exception event when the VM is executing code invoked
   // by the debugger to evaluate variables values, when we see a nested
   // breakpoint or exception event, or if the debugger is not
   // interested in exception events.
   if (ignore_breakpoints_ ||
       (stack_trace_ != NULL) ||
       (event_handler_ == NULL) ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
@@ skipping 776 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart