Track async causal stack traces

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 22276 matching lines @@
 }
 
 
 void StackTrace::SetPcOffsetAtFrame(intptr_t frame_index,
                                     const Smi& pc_offset) const {
   const Array& pc_offset_array = Array::Handle(raw_ptr()->pc_offset_array_);
   pc_offset_array.SetAt(frame_index, pc_offset);
 }
 
 
+void StackTrace::set_async_link(const StackTrace& async_link) const {
+  StorePointer(&raw_ptr()->async_link_, async_link.raw());
+}
+
+
 void StackTrace::set_code_array(const Array& code_array) const {
   StorePointer(&raw_ptr()->code_array_, code_array.raw());
 }
 
 
 void StackTrace::set_pc_offset_array(const Array& pc_offset_array) const {
   StorePointer(&raw_ptr()->pc_offset_array_, pc_offset_array.raw());
 }
 
 
@@ skipping 17 matching lines @@
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_code_array(code_array);
   result.set_pc_offset_array(pc_offset_array);
   result.set_expand_inlined(true);  // default.
   return result.raw();
 }
 
 
+RawStackTrace* StackTrace::New(const Array& code_array,
+                               const Array& pc_offset_array,
+                               const StackTrace& async_link,
+                               Heap::Space space) {
+  StackTrace& result = StackTrace::Handle();
+  {
+    RawObject* raw = Object::Allocate(StackTrace::kClassId,
+                                      StackTrace::InstanceSize(), space);
+    NoSafepointScope no_safepoint;
+    result ^= raw;
+  }
+  result.set_async_link(async_link);
+  result.set_code_array(code_array);
+  result.set_pc_offset_array(pc_offset_array);
+  result.set_expand_inlined(true);  // default.
+  return result.raw();
+}
+
+
 const char* StackTrace::ToCString() const {
   intptr_t idx = 0;
-  return ToCStringInternal(&idx);
+  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);
@@ skipping 21 matching lines @@
                         function_name.ToCString(), url.ToCString(), line);
   } else {
     chars = OS::SCreate(zone, "#%-6" Pd " %s (%s)\n", frame_index,
                         function_name.ToCString(), url.ToCString());
   }
   frame_strings->Add(chars);
   return strlen(chars);
 }
 
 
-const char* StackTrace::ToCStringInternal(intptr_t* frame_index,
-                                          intptr_t max_frames) const {
+const char* StackTrace::ToCStringInternal(const StackTrace& stack_trace_in,
+                                          intptr_t* frame_index,
+                                          intptr_t max_frames) {
   Zone* zone = Thread::Current()->zone();
-  Function& function = Function::Handle();
-  Code& code = Code::Handle();
+  Function& function = Function::Handle(zone);
+  Code& code = Code::Handle(zone);
   // 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()) && (*frame_index < max_frames); i++) {
-    function = FunctionAtFrame(i);
-    if (function.IsNull()) {
-      // Check for a null function, which indicates a gap in a StackOverflow or
-      // OutOfMemory trace.
-      if ((i < (Length() - 1)) &&
-          (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);
+  StackTrace& stack_trace = StackTrace::Handle(zone);
+  stack_trace ^= stack_trace_in.raw();
+  while (!stack_trace.IsNull()) {
+    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 += truncated_len;
-        ASSERT(PcOffsetAtFrame(i) != Smi::null());
-        // To account for gap frames.
-        (*frame_index) += Smi::Value(PcOffsetAtFrame(i));
-      }
-    } else {
-      code = CodeAtFrame(i);
-      ASSERT(function.raw() == code.function());
-      uword pc = code.PayloadStart() + Smi::Value(PcOffsetAtFrame(i));
-      if (code.is_optimized() && expand_inlined() &&
-          !FLAG_precompiled_runtime) {
-        // Traverse inlined frames.
-        for (InlinedFunctionsIterator it(code, pc);
-             !it.Done() && (*frame_index < max_frames); it.Advance()) {
-          function = it.function();
+        total_len += async_suspension_len;
+      } else if (function.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;
+          ASSERT(stack_trace.PcOffsetAtFrame(i) != Smi::null());
+          // To account for gap frames.
+          (*frame_index) += Smi::Value(stack_trace.PcOffsetAtFrame(i));
+        }
+      } else {
+        code = stack_trace.CodeAtFrame(i);
+        ASSERT(function.raw() == code.function());
+        uword pc =
+            code.PayloadStart() + 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.
+            }
+          }
+        } else {
           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.
+            (*frame_index)++;
           }
         }
-      } else {
-        if (function.is_visible() || FLAG_show_invisible_frames) {
-          total_len += PrintOneStackTrace(zone, &frame_strings, pc, function,
-                                          code, *frame_index);
-          (*frame_index)++;
-        }
       }
     }
+    // Follow the link.
+    stack_trace ^= stack_trace.async_link();
   }
 
   // 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';
@@ skipping 315 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart