Add an API function to get a debugger stack trace from an error handle.

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 122 matching lines @@
     const Code& code,
     const Array& deopt_frame,
     intptr_t deopt_frame_offset)
     : pc_(pc), fp_(fp), sp_(sp),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle(code.raw())),
       function_(Function::ZoneHandle(code.function())),
       token_pos_(-1),
       pc_desc_index_(-1),
       line_number_(-1),
+      column_number_(-1),
       context_level_(-1),
       deopt_frame_(Array::ZoneHandle(deopt_frame.raw())),
       deopt_frame_offset_(deopt_frame_offset),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
@@ skipping 135 matching lines @@
 intptr_t ActivationFrame::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if ((line_number_ < 0) && (TokenPos() >= 0)) {
     const Script& script = Script::Handle(SourceScript());
     script.GetTokenLocation(TokenPos(), &line_number_, NULL);
   }
   return line_number_;
 }
 
 
+intptr_t ActivationFrame::ColumnNumber() {
+  // Compute column number lazily since it causes scanning of the script.
+  if ((column_number_ < 0) && (TokenPos() >= 0)) {
+    const Script& script = Script::Handle(SourceScript());
+    if (script.HasSource()) {
+      script.GetTokenLocation(TokenPos(), &line_number_, &column_number_);
+    } else {
+      column_number_ = -1;
+    }
+  }
+  return column_number_;
+}
+
+
 void ActivationFrame::GetVarDescriptors() {
   if (var_descriptors_.IsNull()) {
     var_descriptors_ = code().var_descriptors();
     ASSERT(!var_descriptors_.IsNull());
   }
 }
 
 
 bool ActivationFrame::IsDebuggable() const {
   return Debugger::IsDebuggable(function());
@@ skipping 954 matching lines @@
       new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), code,
                           Object::null_array(), 0);
   return activation;
 }
 
 
 DebuggerStackTrace* Debugger::StackTrace() {
   return (stack_trace_ != NULL) ? stack_trace_ : CollectStackTrace();
 }
 
+DebuggerStackTrace* Debugger::CurrentStackTrace() {
+  return CollectStackTraceNew();
+}
+
+DebuggerStackTrace* Debugger::StackTraceFrom(const Stacktrace& ex_trace) {
+  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
+  Function& function = Function::Handle();
+  Code& code = Code::Handle();
+
+  const uword fp = 0;
+  const uword sp = 0;
+  const Array& deopt_frame = Array::Handle();
+  const intptr_t deopt_frame_offset = -1;
+
+  for (intptr_t i = 0; i < ex_trace.Length(); i++) {
+    function = ex_trace.FunctionAtFrame(i);
+    if (function.IsNull()) {
+      // Check if null function object indicates a stack trace overflow.
+      // Preallocated stacktraces like StackOverflow or OutOfMemory make skip
+      // frames.
+      ASSERT((i < (ex_trace.Length() - 1)) &&
+          (ex_trace.FunctionAtFrame(i + 1) != Function::null()));
+    } else if (function.is_visible()) {
+      code = ex_trace.CodeAtFrame(i);
+      ASSERT(function.raw() == code.function());
+      uword pc = code.EntryPoint() + Smi::Value(ex_trace.PcOffsetAtFrame(i));
+      if (code.is_optimized() && ex_trace.expand_inlined()) {
+        // Traverse inlined frames.
+        for (InlinedFunctionsIterator it(code, pc); !it.Done(); it.Advance()) {
+          function = it.function();
+          code = it.code();
+          ASSERT(function.raw() == code.function());
+          uword pc = it.pc();
+          ASSERT(pc != 0);
+          ASSERT(code.EntryPoint() <= pc);
+          ASSERT(pc < (code.EntryPoint() + code.Size()));
+
+          ActivationFrame* activation = new ActivationFrame(
+            pc, fp, sp, code, deopt_frame, deopt_frame_offset);
+          stack_trace->AddActivation(activation);
+        }
+      } else {
+        ActivationFrame* activation = new ActivationFrame(
+          pc, fp, sp, code, deopt_frame, deopt_frame_offset);
+        stack_trace->AddActivation(activation);
+      }
+    }
+  }
+  return stack_trace;
+}
+
 
 void Debugger::SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info) {
   ASSERT((pause_info == kNoPauseOnExceptions) ||
          (pause_info == kPauseOnUnhandledExceptions) ||
          (pause_info == kPauseOnAllExceptions));
   exc_pause_info_ = pause_info;
 }
 
 
 Dart_ExceptionPauseInfo Debugger::GetExceptionPauseInfo() {
@@ skipping 879 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart