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 9110 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 13370 matching lines @@
 }
 
 
 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);
 
+#if defined(DART_PRECOMPILER) || defined(DART_PRECOMPILED_RUNTIME)
+  if (FLAG_dwarf_stack_traces) {
+    // 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());
+  }
+#endif
+
   // Iterate through the stack frames and create C string description
   // for each frame.
   do {
     for (intptr_t i = 0;
          (i < stack_trace.Length()) && (*frame_index < max_frames); 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 {
         ASSERT(code.IsFunctionCode());
         intptr_t pc_offset = Smi::Value(stack_trace.PcOffsetAtFrame(i));
+
+#if defined(DART_PRECOMPILER) || defined(DART_PRECOMPILED_RUNTIME)
+        if (FLAG_dwarf_stack_traces) {
+          // 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;

[Cutch, 2017/03/15 14:54:13]

This function is getting too complex. Refactor this into a function for printing
stack traces in the Android format.

[rmacnak, 2017/03/16 17:50:11]

Split into Dart and Android print functions. Also removed max_frames, which was
always kMaxInt32.

+          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)++;
+          continue;
+        }
+#endif
+
         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)++;
@@ skipping 333 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart