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

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 15355 matching lines @@
   Isolate* isolate = Isolate::Current();
   Function& function = Function::Handle();
   Code& code = Code::Handle();
   // Iterate through the stack frames and create C string description
   // for each frame.
   intptr_t total_len = 0;
   GrowableArray<char*> frame_strings;
   for (intptr_t i = 0; i < Length(); i++) {
     function = FunctionAtFrame(i);
     if (function.IsNull()) {
-      // Check if null function object indicates a stack trace overflow.
+      // Check for null function object, which indicates a stack trace overflow.

[siva, 2013/10/31 17:13:26]

A null function object doesn't necessarily mean a stack trace overflow, the
original comment tries to convey that.

[rmacnak, 2013/11/07 21:31:12]

Reverted.

       if ((i < (Length() - 1)) &&
           (FunctionAtFrame(i + 1) != Function::null())) {
         const char* kTruncated = "...\n...\n";
         intptr_t truncated_len = strlen(kTruncated) + 1;
         char* chars = isolate->current_zone()->Alloc<char>(truncated_len);
         OS::SNPrint(chars, truncated_len, "%s", kTruncated);
         frame_strings.Add(chars);
       }
     } else if (function.is_visible() || FLAG_verbose_stacktrace) {
       code = CodeAtFrame(i);
@@ skipping 27 matching lines @@
   for (intptr_t i = 0; i < frame_strings.length(); i++) {
     index += OS::SNPrint((chars + index),
                          (total_len + 1 - index),
                          "%s",
                          frame_strings[i]);
   }
   chars[total_len] = '\0';
   return chars;
 }
 
+intptr_t Stacktrace::VisibleLength() const {
+  // Isolate* isolate = Isolate::Current();
+  Function& function = Function::Handle();
+  Code& code = Code::Handle();
+  intptr_t frame_count = 0;
+  for (intptr_t i = 0; i < Length(); i++) {
+    function = FunctionAtFrame(i);
+    if (function.IsNull()) {
+      // Check for null function object, which indicates a stack trace overflow.
+      if ((i < (Length() - 1)) &&
+          (FunctionAtFrame(i + 1) != Function::null())) {
+        // How to inform API users?

[rmacnak, 2013/10/30 16:52:45]

frame_count++ if we indicate the gap. See comment below.

[siva, 2013/10/31 17:13:26]

Since you are handing out actual frames maybe the API implementation should not
try and truncate stuff. The embedder code using the API could try and figure out
how it wants to handle long stack traces.
We should probably do the truncating stuff in the dartium bindings code.

[rmacnak, 2013/11/07 21:31:12]

The truncation for StackOverflow happens before this code runs. Otherwise, this
should be a full trace.

+      }
+    } else if (function.is_visible() || FLAG_verbose_stacktrace) {

[siva, 2013/10/31 17:13:26]

We probably don't want the verbose_stacktrace flag to influence this, we should
only show visible frames.

[rmacnak, 2013/11/07 21:31:12]

Removed.

+      code = CodeAtFrame(i);
+      ASSERT(function.raw() == code.function());
+      uword pc = code.EntryPoint() + Smi::Value(PcOffsetAtFrame(i));
+      if (code.is_optimized() && 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()));
+          frame_count++;
+        }
+      } else {
+        frame_count++;
+      }
+    }
+  }
+  return frame_count;
+}
+
+bool Stacktrace::VisibleFrameInfoAt(intptr_t frame_index,
+                          String* function_name,
+                          String* script_url,
+                          intptr_t* line_number,
+                          intptr_t* col_num) const {
+  ASSERT(function_name);
+  ASSERT(script_url);
+  ASSERT(line_number);
+  ASSERT(col_num);
+
+  if (frame_index < 0) {
+    return false;
+  }
+
+  Isolate* isolate = Isolate::Current();
+  Function& function = Function::Handle();
+  Code& code = Code::Handle();
+  intptr_t frame_count = 0;
+  for (intptr_t i = 0; i < Length(); i++) {
+    function = FunctionAtFrame(i);
+    if (function.IsNull()) {
+      // Check for null function object, which indicates a stack trace overflow.
+      if ((i < (Length() - 1)) &&
+          (FunctionAtFrame(i + 1) != Function::null())) {
+        // How to inform API users?

[rmacnak, 2013/10/30 16:52:45]

Function named '...' at -1, -1?

[siva, 2013/10/31 17:13:26]

Ditto comment as above, the API implementation should not bother with this.

+      }
+    } else if (function.is_visible() || FLAG_verbose_stacktrace) {
+      code = CodeAtFrame(i);
+      ASSERT(function.raw() == code.function());
+      uword pc = code.EntryPoint() + Smi::Value(PcOffsetAtFrame(i));
+      if (code.is_optimized() && 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()));
+
+          if (frame_count == frame_index) {
+            *function_name = function.QualifiedUserVisibleName();

[rmacnak, 2013/10/30 16:52:45]

Might allocate.

+            const Script& script = Script::Handle(isolate, function.script());
+            *script_url = script.url();
+            const intptr_t token_pos = code.GetTokenIndexOfPC(pc);
+            if (token_pos >= 0) {
+              if (script.HasSource()) {
+                script.GetTokenLocation(token_pos, line_number, col_num);
+              } else {
+                script.GetTokenLocation(token_pos, line_number, NULL);
+                *col_num = -1;
+              }
+            }
+            return true;
+          }
+          frame_count++;
+        }
+      } else {
+        if (frame_count == frame_index) {
+          *function_name = function.QualifiedUserVisibleName();

[rmacnak, 2013/10/30 16:52:45]

Might allocate.

+          const Script& script = Script::Handle(isolate, function.script());
+          *script_url = script.url();
+          const intptr_t token_pos = code.GetTokenIndexOfPC(pc);
+          if (token_pos >= 0) {
+            if (script.HasSource()) {
+              script.GetTokenLocation(token_pos, line_number, col_num);
+            } else {
+              script.GetTokenLocation(token_pos, line_number, NULL);
+              *col_num = -1;
+            }
+          }
+          return true;
+        }
+        frame_count++;
+      }
+    }
+  }
+  return false;
+}
+
 
 void JSRegExp::set_pattern(const String& pattern) const {
   StorePointer(&raw_ptr()->pattern_, pattern.raw());
 }
 
 
 void JSRegExp::set_num_bracket_expressions(intptr_t value) const {
   raw_ptr()->num_bracket_expressions_ = Smi::New(value);
 }
 
@@ skipping 167 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart