Fix debugger stack traces

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 277 matching lines @@
 
 
 void ActivationFrame::GetVarDescriptors() {
   if (var_descriptors_.IsNull()) {
     var_descriptors_ = code().var_descriptors();
     ASSERT(!var_descriptors_.IsNull());
   }
 }
 
 
+bool ActivationFrame::IsDebuggable() const {
+  return Debugger::IsDebuggable(function());
+}
+
+
 // Calculate the context level at the current token index of the frame.
 intptr_t ActivationFrame::ContextLevel() {
   if (context_level_ < 0 && !ctx_.IsNull()) {
     ASSERT(!code_.is_optimized());
     context_level_ = 0;
     intptr_t pc_desc_idx = PcDescIndex();
     // TODO(hausner): What to do if there is no descriptor entry
     // for the code position of the frame? For now say we are at context
     // level 0.
     if (pc_desc_idx < 0) {
@@ skipping 62 matching lines @@
   return Context::null();
 }
 
 
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const TypeArguments& no_instantiator = TypeArguments::Handle();
-  for (int frame_index = 0; frame_index < Length(); frame_index++) {
-    ActivationFrame* frame = trace_[frame_index];
+  for (int frame_index = 0; frame_index < UnfilteredLength(); frame_index++) {
+    ActivationFrame* frame = UnfilteredFrameAt(frame_index);
     intptr_t try_index = frame->TryIndex();
     if (try_index < 0) continue;
     handlers = frame->code().exception_handlers();
     ASSERT(!handlers.IsNull());
     intptr_t num_handlers_checked = 0;
     while (try_index >= 0) {
       // Detect circles in the exception handler data.
       num_handlers_checked++;
       ASSERT(num_handlers_checked <= handlers.Length());
       handled_types = handlers.GetHandledTypes(try_index);
@@ skipping 181 matching lines @@
       OS::SNPrint(NULL, 0, kFormat, func_name, url.ToCString(), line);
   len++;  // String terminator.
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
   return chars;
 }
 
 
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   trace_.Add(frame);
+  if (frame->IsDebuggable()) {
+    user_trace_.Add(frame);
+  }
 }
 
 
 static bool IsSafePoint(PcDescriptors::Kind kind) {
   return ((kind == PcDescriptors::kIcCall) ||
           (kind == PcDescriptors::kOptStaticCall) ||
           (kind == PcDescriptors::kUnoptStaticCall) ||
           (kind == PcDescriptors::kClosureCall) ||
           (kind == PcDescriptors::kReturn) ||
           (kind == PcDescriptors::kRuntimeCall));
@@ skipping 377 matching lines @@
         }
       }
       if (optimized_frame_found || code.is_optimized()) {
         // Set context to null, to avoid returning bad context variable values.
         activation->SetContext(Context::Handle());
         optimized_frame_found = true;
       } else {
         ASSERT(!ctx.IsNull());
         activation->SetContext(ctx);
       }
-      // Check if frame is a debuggable function.
-      if (IsDebuggable(activation->function())) {
-        stack_trace->AddActivation(activation);
-      }
+      stack_trace->AddActivation(activation);
       callee_activation = activation;
       // Get caller's context if this function saved it on entry.
       ctx = activation->GetSavedEntryContext(ctx);
     } else if (frame->IsEntryFrame()) {
       ctx = reinterpret_cast<EntryFrame*>(frame)->SavedContext();
       callee_activation = NULL;
     }
   }
   return stack_trace;
 }
@@ skipping 602 matching lines @@
   }
 
   stack_trace_ = CollectStackTrace();
   SignalPausedEvent(frame);
 
   RemoveInternalBreakpoints();
   if (resume_action_ == kStepOver) {
     InstrumentForStepping(func);
   } else if (resume_action_ == kStepOut) {
     if (stack_trace_->Length() > 1) {
-      ActivationFrame* caller_frame = stack_trace_->ActivationFrameAt(1);
+      ActivationFrame* caller_frame = stack_trace_->FrameAt(1);
       InstrumentForStepping(caller_frame->function());
     }
   }
   stack_trace_ = NULL;
 }
 
 
 void Debugger::SignalBpReached() {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
   if (ignore_breakpoints_ || in_event_notification_) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
-  ASSERT(stack_trace->Length() > 0);
-  ActivationFrame* top_frame = stack_trace->ActivationFrameAt(0);
+  ASSERT(stack_trace->UnfilteredLength() > 0);
+  ActivationFrame* top_frame = stack_trace->UnfilteredFrameAt(0);
   ASSERT(top_frame != NULL);
   CodeBreakpoint* bpt = GetCodeBreakpoint(top_frame->pc());
   ASSERT(bpt != NULL);
 
   bool report_bp = true;
   if (bpt->IsInternal() && !IsDebuggable(top_frame->function())) {
     report_bp = false;
   }
   if (FLAG_verbose_debug) {
     OS::Print(">>> %s %s breakpoint at %s:%" Pd " "
@@ skipping 16 matching lines @@
   if (resume_action_ == kStepOver) {
     if (bpt->breakpoint_kind_ == PcDescriptors::kReturn) {
       // Step over return is converted into a single step so we break at
       // the caller.
       SetSingleStep();
     } else {
       func_to_instrument = bpt->function();
     }
   } else if (resume_action_ == kStepOut) {
     if (stack_trace->Length() > 1) {
-      ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
+      ActivationFrame* caller_frame = stack_trace->FrameAt(1);
       func_to_instrument = caller_frame->function().raw();
     }
   } else {
     ASSERT((resume_action_ == kContinue) || (resume_action_ == kSingleStep));
     // Nothing to do here. Any potential instrumentation will be removed
     // below. Single stepping is handled by the single step callback.
   }
 
   if (func_to_instrument.IsNull() ||
       (func_to_instrument.raw() != bpt->function())) {
@@ skipping 194 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart