Reapply "Use CodeSourceMap for stack traces (still JIT only)."

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/become.h"
@@ skipping 29 matching lines @@
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
 #include "vm/timer.h"
 #include "vm/type_table.h"
 #include "vm/unicode.h"
 #include "vm/weak_code.h"
+#include "vm/zone_text_buffer.h"
 
 namespace dart {
 
 DEFINE_FLAG(int,
             huge_method_cutoff_in_code_size,
             200000,
             "Huge method cutoff in unoptimized code size (in bytes).");
 DEFINE_FLAG(
     bool,
     overlap_type_arguments,
@@ skipping 14393 matching lines @@
   // If we are missing a stack map, this must either be unoptimized code, or
   // the entry to an osr function. (In which case all stack slots are
   // considered to have tagged pointers.)
   // Running with --verify-on-transition should hit this.
   ASSERT(!is_optimized() ||
          (pc_offset == UncheckedEntryPoint() - PayloadStart()));
   return StackMap::null();
 }
 
 
-void Code::GetInlinedFunctionsAt(
+void Code::GetInlinedFunctionsAtInstruction(
     intptr_t pc_offset,
     GrowableArray<const Function*>* functions,
     GrowableArray<TokenPosition>* token_positions) const {
   const CodeSourceMap& map = CodeSourceMap::Handle(code_source_map());
   if (map.IsNull()) {
     // Stub code.
     return;
   }
   const Array& id_map = Array::Handle(inlined_id_to_function());
   const Function& root = Function::Handle(function());
@@ skipping 7782 matching lines @@
   return reinterpret_cast<RawClosure*>(raw);
 }
 
 
 intptr_t StackTrace::Length() const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return code_array.Length();
 }
 
 
-RawFunction* StackTrace::FunctionAtFrame(intptr_t frame_index) const {
-  const Code& code = Code::Handle(CodeAtFrame(frame_index));
-  return code.IsNull() ? Function::null() : code.function();
-}
-
-
 RawCode* StackTrace::CodeAtFrame(intptr_t frame_index) const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return reinterpret_cast<RawCode*>(code_array.At(frame_index));
 }
 
 
 void StackTrace::SetCodeAtFrame(intptr_t frame_index, const Code& code) const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   code_array.SetAt(frame_index, code);
 }
@@ skipping 72 matching lines @@
   return result.raw();
 }
 
 
 const char* StackTrace::ToCString() const {
   intptr_t idx = 0;
   return ToCStringInternal(*this, &idx);
 }
 
 
-static intptr_t PrintOneStackTrace(Zone* zone,
-                                   GrowableArray<char*>* frame_strings,
-                                   uword pc,
-                                   const Function& function,
-                                   const Code& code,
-                                   intptr_t frame_index) {
-  const TokenPosition token_pos = code.GetTokenIndexOfPC(pc);
+static void PrintStackTraceFrame(Zone* zone,
+                                 ZoneTextBuffer* buffer,
+                                 const Function& function,
+                                 TokenPosition token_pos,
+                                 intptr_t frame_index) {
   const Script& script = Script::Handle(zone, function.script());
   const String& function_name =
       String::Handle(zone, function.QualifiedUserVisibleName());
   const String& url = String::Handle(
       zone, script.IsNull() ? String::New("Kernel") : script.url());
   intptr_t line = -1;
   intptr_t column = -1;
   if (!script.IsNull() && token_pos.IsReal()) {
     if (script.HasSource() || script.kind() == RawScript::kKernelTag) {
       script.GetTokenLocation(token_pos, &line, &column);
     } else {
       script.GetTokenLocation(token_pos, &line, NULL);
     }
   }
-  char* chars = NULL;
   if (column >= 0) {
-    chars =
-        OS::SCreate(zone, "#%-6" Pd " %s (%s:%" Pd ":%" Pd ")\n", frame_index,
-                    function_name.ToCString(), url.ToCString(), line, column);
+    buffer->Printf("#%-6" Pd " %s (%s:%" Pd ":%" Pd ")\n", frame_index,
+                   function_name.ToCString(), url.ToCString(), line, column);
   } else if (line >= 0) {
-    chars = OS::SCreate(zone, "#%-6" Pd " %s (%s:%" Pd ")\n", frame_index,
-                        function_name.ToCString(), url.ToCString(), line);
+    buffer->Printf("#%-6" Pd " %s (%s:%" Pd ")\n", frame_index,
+                   function_name.ToCString(), url.ToCString(), line);
   } else {
-    chars = OS::SCreate(zone, "#%-6" Pd " %s (%s)\n", frame_index,
-                        function_name.ToCString(), url.ToCString());
+    buffer->Printf("#%-6" Pd " %s (%s)\n", frame_index,
+                   function_name.ToCString(), url.ToCString());
   }
-  frame_strings->Add(chars);
-  return strlen(chars);
 }
 
 
 const char* StackTrace::ToCStringInternal(const StackTrace& stack_trace_in,
                                           intptr_t* frame_index,
                                           intptr_t max_frames) {
   Zone* zone = Thread::Current()->zone();
+  StackTrace& stack_trace = StackTrace::Handle(zone, stack_trace_in.raw());
   Function& function = Function::Handle(zone);
   Code& code = Code::Handle(zone);
+  GrowableArray<const Function*> inlined_functions;
+  GrowableArray<TokenPosition> inlined_token_positions;
+  ZoneTextBuffer buffer(zone, 1024);
+
   // Iterate through the stack frames and create C string description
   // for each frame.
-  intptr_t total_len = 0;
-  GrowableArray<char*> frame_strings;
-  StackTrace& stack_trace = StackTrace::Handle(zone);
-  stack_trace ^= stack_trace_in.raw();
-  while (!stack_trace.IsNull()) {
+  do {
     for (intptr_t i = 0;
          (i < stack_trace.Length()) && (*frame_index < max_frames); i++) {
       code = stack_trace.CodeAtFrame(i);
-      function = stack_trace.FunctionAtFrame(i);
-      if (code.raw() == StubCode::AsynchronousGapMarker_entry()->code()) {
-        const char* kAsyncSuspension = "<asynchronous suspension>\n";
-        intptr_t async_suspension_len = strlen(kAsyncSuspension) + 1;
-        char* chars = zone->Alloc<char>(async_suspension_len);
-        OS::SNPrint(chars, async_suspension_len, "%s", kAsyncSuspension);
-        frame_strings.Add(chars);
-        total_len += async_suspension_len;
-      } else if (function.IsNull()) {
+      if (code.IsNull()) {
         // Check for a null function, which indicates a gap in a StackOverflow
         // or OutOfMemory trace.
         if ((i < (stack_trace.Length() - 1)) &&
-            (stack_trace.FunctionAtFrame(i + 1) != Function::null())) {
-          const char* kTruncated = "...\n...\n";
-          intptr_t truncated_len = strlen(kTruncated) + 1;
-          char* chars = zone->Alloc<char>(truncated_len);
-          OS::SNPrint(chars, truncated_len, "%s", kTruncated);
-          frame_strings.Add(chars);
-          total_len += truncated_len;
+            (stack_trace.CodeAtFrame(i + 1) != Code::null())) {
+          buffer.AddString("...\n...\n");
           ASSERT(stack_trace.PcOffsetAtFrame(i) != Smi::null());
           // To account for gap frames.
           (*frame_index) += Smi::Value(stack_trace.PcOffsetAtFrame(i));
         }
+      } else if (code.raw() ==
+                 StubCode::AsynchronousGapMarker_entry()->code()) {
+        buffer.AddString("<asynchronous suspension>\n");
       } else {
-        code = stack_trace.CodeAtFrame(i);
-        ASSERT(function.raw() == code.function());
-        uword pc =
-            code.PayloadStart() + Smi::Value(stack_trace.PcOffsetAtFrame(i));
+        ASSERT(code.IsFunctionCode());
+        intptr_t pc_offset = Smi::Value(stack_trace.PcOffsetAtFrame(i));
         if (code.is_optimized() && stack_trace.expand_inlined() &&
             !FLAG_precompiled_runtime) {
-          // Traverse inlined frames.
-          for (InlinedFunctionsIterator it(code, pc);
-               !it.Done() && (*frame_index < max_frames); it.Advance()) {
-            function = it.function();
-            if (function.is_visible() || FLAG_show_invisible_frames) {
-              code = it.code();
-              ASSERT(function.raw() == code.function());
-              uword pc = it.pc();
-              ASSERT(pc != 0);
-              ASSERT(code.PayloadStart() <= pc);
-              ASSERT(pc < (code.PayloadStart() + code.Size()));
-              total_len += PrintOneStackTrace(zone, &frame_strings, pc,
-                                              function, code, *frame_index);
-              (*frame_index)++;  // To account for inlined frames.
+          code.GetInlinedFunctionsAtReturnAddress(pc_offset, &inlined_functions,
+                                                  &inlined_token_positions);
+          ASSERT(inlined_functions.length() >= 1);
+          for (intptr_t j = inlined_functions.length() - 1; j >= 0; j--) {
+            if (inlined_functions[j]->is_visible() ||
+                FLAG_show_invisible_frames) {
+              PrintStackTraceFrame(zone, &buffer, *inlined_functions[j],
+                                   inlined_token_positions[j], *frame_index);
+              (*frame_index)++;
             }
           }
         } else {
+          function = code.function();
           if (function.is_visible() || FLAG_show_invisible_frames) {
-            total_len += PrintOneStackTrace(zone, &frame_strings, pc, function,
-                                            code, *frame_index);
+            uword pc = code.PayloadStart() + pc_offset;
+            const TokenPosition token_pos = code.GetTokenIndexOfPC(pc);
+            PrintStackTraceFrame(zone, &buffer, function, token_pos,
+                                 *frame_index);
             (*frame_index)++;
           }
         }
       }
     }
     // Follow the link.
     stack_trace ^= stack_trace.async_link();
-  }
+  } while (!stack_trace.IsNull());
 
-  // Now concatenate the frame descriptions into a single C string.
-  char* chars = zone->Alloc<char>(total_len + 1);
-  intptr_t index = 0;
-  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;
+  return buffer.buffer();
 }
 
 
 void RegExp::set_pattern(const String& pattern) const {
   StorePointer(&raw_ptr()->pattern_, pattern.raw());
 }
 
 
 void RegExp::set_function(intptr_t cid,
                           bool sticky,
@@ skipping 304 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart