Sane asynchronous debugging and 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 10641 matching lines @@
       &result.raw_ptr()->patch_classes_,
       GrowableObjectArray::New(Object::empty_array(), Heap::kOld));
   result.StorePointer(&result.raw_ptr()->imports_, Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->exports_, Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->loaded_scripts_, Array::null());
   result.StorePointer(&result.raw_ptr()->load_error_, Instance::null());
   result.set_native_entry_resolver(NULL);
   result.set_native_entry_symbol_resolver(NULL);
   result.set_is_in_fullsnapshot(false);
   result.StoreNonPointer(&result.raw_ptr()->corelib_imported_, true);
-  result.set_debuggable(!dart_private_scheme);
+  if (dart_private_scheme) {
+    // Never debug dart:_ libraries.
+    result.set_debuggable(false);
+  } else if (dart_scheme) {
+    // Only debug dart: libraries if we have been requested to show invisible
+    // frames.
+    result.set_debuggable(FLAG_show_invisible_frames);
+  } else {
+    // Default to debuggable for all other libraries.
+    result.set_debuggable(true);
+  }
   result.set_is_dart_scheme(dart_scheme);
   result.StoreNonPointer(&result.raw_ptr()->load_state_,
                          RawLibrary::kAllocated);
   result.StoreNonPointer(&result.raw_ptr()->index_, -1);
   const intptr_t kInitialNameCacheSize = 64;
   result.InitResolvedNamesCache(kInitialNameCacheSize);
   result.InitClassDictionary();
   result.InitImportList();
   result.AllocatePrivateKey();
   if (import_core_lib) {
@@ skipping 3386 matching lines @@
     return Code::null();
   }
   const Array& array = Array::Handle(raw_ptr()->static_calls_target_table_);
   Code& code = Code::Handle();
   code ^= array.At(i + kSCallTableCodeEntry);
   return code.raw();
 #endif
 }
 
 
+void Code::SetAwaitTokenPositions(const Array& await_token_positions) const {
+#if defined(DART_PRECOMPILED_RUNTIME)
+  UNREACHABLE();
+#else
+  ASSERT(await_token_positions.IsOld());
+  StorePointer(&raw_ptr()->await_token_positions_, await_token_positions.raw());
+#endif
+}
+
+
 void Code::SetStaticCallTargetCodeAt(uword pc, const Code& code) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   const intptr_t i = BinarySearchInSCallTable(pc);
   ASSERT(i >= 0);
   const Array& array = Array::Handle(raw_ptr()->static_calls_target_table_);
   ASSERT(code.IsNull() ||
          (code.function() == array.At(i + kSCallTableFunctionEntry)));
   array.SetAt(i + kSCallTableCodeEntry, code);
@@ skipping 8539 matching lines @@
 const char* StackTrace::ToCStringInternal(intptr_t* frame_index,
                                           intptr_t max_frames) const {
   Zone* zone = Thread::Current()->zone();
   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()) && (*frame_index < max_frames); i++) {
+    code = CodeAtFrame(i);
     function = FunctionAtFrame(i);
-    if (function.IsNull()) {
+    if (code.raw() == StubCode::AsynchronousGapMarker_entry()->code()) {
+      const char* kAsynchronousGap = "<asynchronous suspension>\n";
+      intptr_t asynchronous_gap_len = strlen(kAsynchronousGap) + 1;
+      char* chars = zone->Alloc<char>(asynchronous_gap_len);
+      OS::SNPrint(chars, asynchronous_gap_len, "%s", kAsynchronousGap);
+      frame_strings.Add(chars);
+      total_len += asynchronous_gap_len;
+    } else 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);
         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();
           if (function.is_visible() || FLAG_show_invisible_frames) {
             code = it.code();
@@ skipping 343 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart