DWARF and unwind support for AOT assembly output.

runtime/vm/snapshot.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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_entry.h"
+#include "vm/dwarf.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot_ids.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/timeline.h"
@@ skipping 738 matching lines @@
     stream->WriteWord(marked_tags);
     start += sizeof(uword);
     for (uword* cursor = reinterpret_cast<uword*>(start);
          cursor < reinterpret_cast<uword*>(end); cursor++) {
       stream->WriteWord(*cursor);
     }
   }
 }
 
 
+AssemblyImageWriter::AssemblyImageWriter(uint8_t** assembly_buffer,
+                                         ReAlloc alloc,
+                                         intptr_t initial_size)
+    : ImageWriter(),
+      assembly_stream_(assembly_buffer, alloc, initial_size),
+      text_size_(0),
+      dwarf_(NULL) {
+#if defined(DART_PRECOMPILER)
+  Zone* zone = Thread::Current()->zone();
+  dwarf_ = new (zone) Dwarf(zone, &assembly_stream_);
+#endif
+}
+
+
 static void EnsureIdentifier(char* label) {
   for (char c = *label; c != '\0'; c = *++label) {
     if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) ||
         ((c >= '0') && (c <= '9'))) {
       continue;
     }
     *label = '_';
   }
 }
 
 
 void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
   Zone* zone = Thread::Current()->zone();
 
   const char* instructions_symbol =
       vm ? "_kDartVmSnapshotInstructions" : "_kDartIsolateSnapshotInstructions";
   assembly_stream_.Print(".text\n");
   assembly_stream_.Print(".globl %s\n", instructions_symbol);
+
   // Start snapshot at page boundary.
   ASSERT(VirtualMemory::PageSize() >= OS::kMaxPreferredCodeAlignment);
   assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
   assembly_stream_.Print("%s:\n", instructions_symbol);
 
   // This head also provides the gap to make the instructions snapshot
   // look like a HeapPage.
   intptr_t instructions_length = next_offset_;
   WriteWordLiteralText(instructions_length);
   intptr_t header_words = Image::kHeaderSize / sizeof(uword);
   for (intptr_t i = 1; i < header_words; i++) {
     WriteWordLiteralText(0);
   }
 
+  FrameUnwindPrologue();
+
   Object& owner = Object::Handle(zone);
   String& str = String::Handle(zone);
 
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     const Instructions& insns = *instructions_[i].insns_;
     const Code& code = *instructions_[i].code_;
 
     ASSERT(insns.raw()->Size() % sizeof(uint64_t) == 0);
 
     // 1. Write from the header to the entry point.
     {
       NoSafepointScope no_safepoint;
 
       uword beginning = reinterpret_cast<uword>(insns.raw_ptr());
       uword entry = beginning + Instructions::HeaderSize();
 
-      ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
-      ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
-
       // Write Instructions with the mark and VM heap bits set.
       uword marked_tags = insns.raw_ptr()->tags_;
       marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
       marked_tags = RawObject::MarkBit::update(true, marked_tags);
 
       WriteWordLiteralText(marked_tags);
       beginning += sizeof(uword);
 
-      for (uword* cursor = reinterpret_cast<uword*>(beginning);
-           cursor < reinterpret_cast<uword*>(entry); cursor++) {
-        WriteWordLiteralText(*cursor);
-      }
+      WriteByteSequence(beginning, entry);
     }
 
     // 2. Write a label at the entry point.
+    // Linux's perf uses these labels.
     owner = code.owner();
     if (owner.IsNull()) {
       const char* name = StubCode::NameOfStub(insns.UncheckedEntryPoint());
       assembly_stream_.Print("Precompiled_Stub_%s:\n", name);
     } else if (owner.IsClass()) {
       str = Class::Cast(owner).Name();
       const char* name = str.ToCString();
       EnsureIdentifier(const_cast<char*>(name));
       assembly_stream_.Print("Precompiled_AllocationStub_%s_%" Pd ":\n", name,
                              i);
     } else if (owner.IsFunction()) {
       const char* name = Function::Cast(owner).ToQualifiedCString();
       EnsureIdentifier(const_cast<char*>(name));
       assembly_stream_.Print("Precompiled_%s_%" Pd ":\n", name, i);
     } else {
       UNREACHABLE();
     }
 
+#ifdef DART_PRECOMPILER
+    // Create a label for use by DWARF.
+    intptr_t dwarf_index = dwarf_->AddCode(code);
+    assembly_stream_.Print(".Lcode%" Pd ":\n", dwarf_index);
+#endif
+
     {
       // 3. Write from the entry point to the end.
       NoSafepointScope no_safepoint;
       uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
       uword entry = beginning + Instructions::HeaderSize();
       uword payload_size = insns.Size();
       payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
       uword end = entry + payload_size;
 
-      ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
-      ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
-      ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
+      ASSERT(Utils::IsAligned(beginning, sizeof(uword)));
+      ASSERT(Utils::IsAligned(entry, sizeof(uword)));
+      ASSERT(Utils::IsAligned(end, sizeof(uword)));
 
-      for (uword* cursor = reinterpret_cast<uword*>(entry);
-           cursor < reinterpret_cast<uword*>(end); cursor++) {
-        WriteWordLiteralText(*cursor);
-      }
+      WriteByteSequence(entry, end);
     }
   }
 
+  FrameUnwindEpilogue();
 
 #if defined(TARGET_OS_LINUX)
   assembly_stream_.Print(".section .rodata\n");
 #elif defined(TARGET_OS_MACOS)
   assembly_stream_.Print(".const\n");
 #else
   // Unsupported platform.
   UNREACHABLE();
 #endif
 
   const char* data_symbol =
       vm ? "_kDartVmSnapshotData" : "_kDartIsolateSnapshotData";
   assembly_stream_.Print(".globl %s\n", data_symbol);
   assembly_stream_.Print(".balign %" Pd ", 0\n",
                          OS::kMaxPreferredCodeAlignment);
   assembly_stream_.Print("%s:\n", data_symbol);
-  uint8_t* buffer = clustered_stream->buffer();
+  uword buffer = reinterpret_cast<uword>(clustered_stream->buffer());
   intptr_t length = clustered_stream->bytes_written();
-  for (intptr_t i = 0; i < length; i++) {
-    assembly_stream_.Print(".byte %" Pd "\n", buffer[i]);
+  WriteByteSequence(buffer, buffer + length);
+
+#ifdef DART_PRECOMPILER
+  if (!vm) {
+    dwarf_->Write();

[Florian Schneider, 2017/03/15 18:15:06]

Maybe move this outside of WriteText instead of having it conditionally here.

+  }
+#endif
+}
+
+
+void AssemblyImageWriter::FrameUnwindPrologue() {
+  // Creates DWARF's .debug_frame
+  // CFI = Call frame information
+  // CFA = Canonical frame address
+  assembly_stream_.Print(".cfi_startproc\n");
+
+#if defined(TARGET_ARCH_X64)
+  assembly_stream_.Print(".cfi_def_cfa rbp, 0\n");  // CFA is fp+0
+  assembly_stream_.Print(".cfi_offset rbp, 0\n");   // saved fp is *(CFA+0)
+  assembly_stream_.Print(".cfi_offset rip, 8\n");   // saved pc is *(CFA+8)
+  // saved sp is CFA+16
+  // Should be ".cfi_value_offset rsp, 16", but requires gcc newer than late
+  // 2016 and not supported by Android's libunwind.
+  // DW_CFA_expression          0x10
+  // uleb128 register (rsp)        7   (DWARF register number)
+  // uleb128 size of operation     2
+  // DW_OP_plus_uconst          0x23
+  // uleb128 addend               16
+  assembly_stream_.Print(".cfi_escape 0x10, 31, 2, 0x23, 16\n");
+
+#elif defined(TARGET_ARCH_ARM64)
+  COMPILE_ASSERT(FP == R29);
+  COMPILE_ASSERT(LR == R30);
+  assembly_stream_.Print(".cfi_def_cfa x29, 0\n");  // CFA is fp+0
+  assembly_stream_.Print(".cfi_offset x29, 0\n");   // saved fp is *(CFA+0)
+  assembly_stream_.Print(".cfi_offset x30, 8\n");   // saved pc is *(CFA+8)
+  // saved sp is CFA+16
+  // Should be ".cfi_value_offset sp, 16", but requires gcc newer than late
+  // 2016 and not supported by Android's libunwind.
+  // DW_CFA_expression          0x10
+  // uleb128 register (x31)       31
+  // uleb128 size of operation     2
+  // DW_OP_plus_uconst          0x23
+  // uleb128 addend               16
+  assembly_stream_.Print(".cfi_escape 0x10, 31, 2, 0x23, 16\n");
+
+#elif defined(TARGET_ARCH_ARM)
+#if defined(TARGET_ABI_EABI)
+  COMPILE_ASSERT(FP == R11);
+  assembly_stream_.Print(".cfi_def_cfa r11, 0\n");  // CFA is fp+0
+  assembly_stream_.Print(".cfi_offset r11, 0\n");   // saved fp is *(CFA+0)
+#elif defined(TARGET_ABI_IOS)
+  COMPILE_ASSERT(FP == R7);
+  assembly_stream_.Print(".cfi_def_cfa r7, 0\n");  // CFA is fp+0
+  assembly_stream_.Print(".cfi_offset r7, 0\n");   // saved fp is *(CFA+0)
+#endif
+  assembly_stream_.Print(".cfi_offset lr, 4\n");    // saved pc is *(CFA+4)
+  // saved sp is CFA+8
+  // Should be ".cfi_value_offset sp, 8", but requires gcc newer than late
+  // 2016 and not supported by Android's libunwind.
+  // DW_CFA_expression          0x10
+  // uleb128 register (sp)        13
+  // uleb128 size of operation     2
+  // DW_OP_plus_uconst          0x23
+  // uleb128 addend                8
+  assembly_stream_.Print(".cfi_escape 0x10, 13, 2, 0x23, 8\n");
+
+// libunwind on ARM may use .ARM.exidx instead of .debug_frame
+#if defined(TARGET_ABI_EABI)
+  COMPILE_ASSERT(FP == R11);
+  assembly_stream_.Print(".fnstart\n");
+  assembly_stream_.Print(".save {r11, lr}\n");
+  assembly_stream_.Print(".setfp r11, sp, #0\n");
+#elif defined(TARGET_ABI_IOS)
+  COMPILE_ASSERT(FP == R7);
+  assembly_stream_.Print(".fnstart\n");
+  assembly_stream_.Print(".save {r7, lr}\n");
+  assembly_stream_.Print(".setfp r7, sp, #0\n");
+#endif
+
+#elif defined(TARGET_ARCH_MIPS)
+  COMPILE_ASSERT(FP == R30);
+  COMPILE_ASSERT(RA == R31);
+  assembly_stream_.Print(".cfi_def_cfa r30, 0\n");  // CFA is fp+0
+  assembly_stream_.Print(".cfi_offset r30, 0\n");   // saved fp is *(CFA+0)
+  assembly_stream_.Print(".cfi_offset r31, 4\n");   // saved pc is *(CFA+4)
+  // saved sp is CFA+16
+  // Should be ".cfi_value_offset sp, 8", but requires gcc newer than late
+  // 2016 and not supported by Android's libunwind.
+  // DW_CFA_expression          0x10
+  // uleb128 register (sp)        29
+  // uleb128 size of operation     2
+  // DW_OP_plus_uconst          0x23
+  // uleb128 addend                8
+  assembly_stream_.Print(".cfi_escape 0x10, 29, 2, 0x23, 8\n");
+#endif
+}
+
+
+void AssemblyImageWriter::FrameUnwindEpilogue() {
+#if defined(TARGET_ARCH_ARM)
+  assembly_stream_.Print(".fnend\n");
+#endif
+  assembly_stream_.Print(".cfi_endproc\n");
+}
+
+
+void AssemblyImageWriter::WriteByteSequence(uword start, uword end) {
+  for (uword* cursor = reinterpret_cast<uword*>(start);
+       cursor < reinterpret_cast<uword*>(end); cursor++) {
+    WriteWordLiteralText(*cursor);
   }
 }
 
 
 void BlobImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
   // This header provides the gap to make the instructions snapshot look like a
   // HeapPage.
   intptr_t instructions_length = next_offset_;
   instructions_blob_stream_.WriteWord(instructions_length);
   intptr_t header_words = Image::kHeaderSize / sizeof(uword);
   for (intptr_t i = 1; i < header_words; i++) {
     instructions_blob_stream_.WriteWord(0);
   }
 
+  NoSafepointScope no_safepoint;
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     const Instructions& insns = *instructions_[i].insns_;
 
-    // 1. Write from the header to the entry point.
-    {
-      NoSafepointScope no_safepoint;
+    uword beginning = reinterpret_cast<uword>(insns.raw_ptr());
+    uword entry = beginning + Instructions::HeaderSize();
+    uword payload_size = insns.Size();
+    payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
+    uword end = entry + payload_size;
 
-      uword beginning = reinterpret_cast<uword>(insns.raw_ptr());
-      uword entry = beginning + Instructions::HeaderSize();
+    ASSERT(Utils::IsAligned(beginning, sizeof(uword)));
+    ASSERT(Utils::IsAligned(entry, sizeof(uword)));
 
-      ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
-      ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
+    // Write Instructions with the mark and VM heap bits set.
+    uword marked_tags = insns.raw_ptr()->tags_;
+    marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
+    marked_tags = RawObject::MarkBit::update(true, marked_tags);
 
-      // Write Instructions with the mark and VM heap bits set.
-      uword marked_tags = insns.raw_ptr()->tags_;
-      marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
-      marked_tags = RawObject::MarkBit::update(true, marked_tags);
+    instructions_blob_stream_.WriteWord(marked_tags);
+    beginning += sizeof(uword);
 
-      instructions_blob_stream_.WriteWord(marked_tags);
-      beginning += sizeof(uword);
-
-      for (uword* cursor = reinterpret_cast<uword*>(beginning);
-           cursor < reinterpret_cast<uword*>(entry); cursor++) {
-        instructions_blob_stream_.WriteWord(*cursor);
-      }
-    }
-
-    // 2. Write from the entry point to the end.
-    {
-      NoSafepointScope no_safepoint;
-      uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
-      uword entry = beginning + Instructions::HeaderSize();
-      uword payload_size = insns.Size();
-      payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
-      uword end = entry + payload_size;
-
-      ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
-      ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
-      ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
-
-      for (uword* cursor = reinterpret_cast<uword*>(entry);
-           cursor < reinterpret_cast<uword*>(end); cursor++) {
-        instructions_blob_stream_.WriteWord(*cursor);
-      }
+    for (uword* cursor = reinterpret_cast<uword*>(beginning);
+         cursor < reinterpret_cast<uword*>(end); cursor++) {
+      instructions_blob_stream_.WriteWord(*cursor);
     }
   }
 }
 
 
 RawInstructions* InstructionsReader::GetInstructionsAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, OS::PreferredCodeAlignment()));
 
   RawInstructions* result = reinterpret_cast<RawInstructions*>(
       reinterpret_cast<uword>(instructions_buffer_) + offset + kHeapObjectTag);
@@ skipping 977 matching lines @@
       *buffer_len_ = BytesWritten();
     }
   } else {
     FreeBuffer();
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart