DWARF and unwind support for AOT assembly output.

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 12 matching lines @@
 #include "vm/deopt_instructions.h"
 #include "vm/disassembler.h"
 #include "vm/double_conversion.h"
 #include "vm/exceptions.h"
 #include "vm/growable_array.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
 #include "vm/intrinsifier.h"
 #include "vm/isolate_reload.h"
 #include "vm/kernel_to_il.h"
+#include "vm/native_symbol.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/precompiler.h"
 #include "vm/profiler.h"
 #include "vm/resolver.h"
 #include "vm/reusable_handles.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
@@ skipping 9125 matching lines @@
         token_pos = Smi::New(tkit.CurrentPosition().value() + 1);
         line_starts_list.Add(token_pos);
       }
       tkit.Advance();
     }
     line_starts_array = Array::MakeArray(line_starts_list);
     set_line_starts(line_starts_array);
   }
 
   ASSERT(line_starts_array.Length() > 0);
-  intptr_t offset = target_token_pos.value();
+  intptr_t offset = target_token_pos.Pos();
   intptr_t min = 0;
   intptr_t max = line_starts_array.Length() - 1;
 
   // Binary search to find the line containing this offset.
   while (min < max) {
     int midpoint = (max - min + 1) / 2 + min;
     token_pos ^= line_starts_array.At(midpoint);
     if (token_pos.Value() > offset) {
       max = midpoint - 1;
     } else {
@@ skipping 13358 matching lines @@
     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(*this, &idx);
-}
-
-
 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());
@@ skipping 16 matching lines @@
   } else if (line >= 0) {
     buffer->Printf("#%-6" Pd " %s (%s:%" Pd ")\n", frame_index,
                    function_name.ToCString(), url.ToCString(), line);
   } else {
     buffer->Printf("#%-6" Pd " %s (%s)\n", frame_index,
                    function_name.ToCString(), url.ToCString());
   }
 }
 
 
-const char* StackTrace::ToCStringInternal(const StackTrace& stack_trace_in,
-                                          intptr_t* frame_index,
-                                          intptr_t max_frames) {
+const char* StackTrace::ToDartCString(const StackTrace& stack_trace_in) {
   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 frame_index = 0;
   do {
-    for (intptr_t i = 0;
-         (i < stack_trace.Length()) && (*frame_index < max_frames); i++) {
+    for (intptr_t i = 0; i < stack_trace.Length(); i++) {
       code = stack_trace.CodeAtFrame(i);
       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.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));
+          frame_index += Smi::Value(stack_trace.PcOffsetAtFrame(i));
         }
       } else if (code.raw() ==
                  StubCode::AsynchronousGapMarker_entry()->code()) {
         buffer.AddString("<asynchronous suspension>\n");
         // The frame immediately after the asynchronous gap marker is the
         // identical to the frame above the marker. Skip the frame to enhance
         // the readability of the trace.
         i++;
       } else {
         ASSERT(code.IsFunctionCode());
         intptr_t pc_offset = Smi::Value(stack_trace.PcOffsetAtFrame(i));
         if (code.is_optimized() && stack_trace.expand_inlined()) {
           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)++;
+                                   inlined_token_positions[j], frame_index);
+              frame_index++;
             }
           }
         } else {
           function = code.function();
           if (function.is_visible() || FLAG_show_invisible_frames) {
             uword pc = code.PayloadStart() + pc_offset;
             const TokenPosition token_pos = code.GetTokenIndexOfPC(pc);
             PrintStackTraceFrame(zone, &buffer, function, token_pos,
-                                 *frame_index);
-            (*frame_index)++;
+                                 frame_index);
+            frame_index++;
           }
         }
       }
     }
     // Follow the link.
     stack_trace ^= stack_trace.async_link();
   } while (!stack_trace.IsNull());
 
   return buffer.buffer();
 }
 
 
+const char* StackTrace::ToDwarfCString(const StackTrace& stack_trace_in) {
+#if defined(DART_PRECOMPILER) || defined(DART_PRECOMPILED_RUNTIME)
+  Zone* zone = Thread::Current()->zone();
+  StackTrace& stack_trace = StackTrace::Handle(zone, stack_trace_in.raw());
+  Code& code = Code::Handle(zone);
+  ZoneTextBuffer buffer(zone, 1024);
+
+  // The Dart standard requires the output of StackTrace.toString to include
+  // all pending activations with precise source locations (i.e., to expand
+  // inlined frames and provide line and column numbers).
+  buffer.Printf(
+      "Warning: This VM has been configured to produce stack traces "
+      "that violate the Dart standard.\n");
+  // This prologue imitates Android's debuggerd to make it possible to paste
+  // the stack trace into ndk-stack.
+  buffer.Printf(
+      "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
+  OSThread* thread = OSThread::Current();
+  buffer.Printf("pid: %" Pd ", tid: %" Pd ", name %s\n", OS::ProcessId(),
+                OSThread::ThreadIdToIntPtr(thread->id()), thread->name());
+  intptr_t frame_index = 0;
+  do {
+    for (intptr_t i = 0; i < stack_trace.Length(); i++) {
+      code = stack_trace.CodeAtFrame(i);
+      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.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");
+        // The frame immediately after the asynchronous gap marker is the
+        // identical to the frame above the marker. Skip the frame to enhance
+        // the readability of the trace.
+        i++;
+      } else {
+        intptr_t pc_offset = Smi::Value(stack_trace.PcOffsetAtFrame(i));
+        // This output is formatted like Android's debuggerd. Note debuggerd
+        // prints call addresses instead of return addresses.
+        uword return_addr = code.PayloadStart() + pc_offset;
+        uword call_addr = return_addr - 1;
+        uword dso_base;
+        char* dso_name;
+        if (NativeSymbolResolver::LookupSharedObject(call_addr, &dso_base,
+                                                     &dso_name)) {
+          uword dso_offset = call_addr - dso_base;
+          buffer.Printf("    #%02" Pd " pc %" Pp "  %s\n", frame_index,
+                        dso_offset, dso_name);
+          NativeSymbolResolver::FreeSymbolName(dso_name);
+        } else {
+          buffer.Printf("    #%02" Pd " pc %" Pp "  <unknown>\n", frame_index,
+                        call_addr);
+        }
+        frame_index++;
+      }
+    }
+    // Follow the link.
+    stack_trace ^= stack_trace.async_link();
+  } while (!stack_trace.IsNull());
+
+  return buffer.buffer();
+#else
+  UNREACHABLE();
+  return NULL;
+#endif  // defined(DART_PRECOMPILER) || defined(DART_PRECOMPILED_RUNTIME)
+}
+
+
+const char* StackTrace::ToCString() const {
+#if defined(DART_PRECOMPILER) || defined(DART_PRECOMPILED_RUNTIME)
+  if (FLAG_dwarf_stack_traces) {
+    return ToDwarfCString(*this);
+  }
+#endif
+  return ToDartCString(*this);
+}
+
+
 void RegExp::set_pattern(const String& pattern) const {
   StorePointer(&raw_ptr()->pattern_, pattern.raw());
 }
 
 
 void RegExp::set_function(intptr_t cid,
                           bool sticky,
                           const Function& value) const {
   StorePointer(FunctionAddr(cid, sticky), value.raw());
 }
@@ skipping 301 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart