Initial support for emitting unwinding information in perf jitdump.

src/perf-jit.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "src/perf-jit.h"
 
 #include "src/assembler.h"
 #include "src/objects-inl.h"
+#include "src/unwinding-info.h"
 
 #if V8_OS_LINUX
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #endif  // V8_OS_LINUX
 
 namespace v8 {
 namespace internal {
 
 #if V8_OS_LINUX
 
 struct PerfJitHeader {
   uint32_t magic_;
   uint32_t version_;
   uint32_t size_;
   uint32_t elf_mach_target_;
   uint32_t reserved_;
   uint32_t process_id_;
   uint64_t time_stamp_;
   uint64_t flags_;
 
   static const uint32_t kMagic = 0x4A695444;
   static const uint32_t kVersion = 1;
 };
 
 struct PerfJitBase {
-  enum PerfJitEvent { kLoad = 0, kMove = 1, kDebugInfo = 2, kClose = 3 };
+  enum PerfJitEvent {
+    kLoad = 0,
+    kMove = 1,
+    kDebugInfo = 2,
+    kClose = 3,
+    kUnwindingInfo = 4
+  };
 
   uint32_t event_;
   uint32_t size_;
   uint64_t time_stamp_;
 };
 
 struct PerfJitCodeLoad : PerfJitBase {
   uint32_t process_id_;
   uint32_t thread_id_;
   uint64_t vma_;
   uint64_t code_address_;
   uint64_t code_size_;
   uint64_t code_id_;
 };
 
 struct PerfJitDebugEntry {
   uint64_t address_;
   int line_number_;
   int column_;
   // Followed by null-terminated name or \0xff\0 if same as previous.
 };
 
 struct PerfJitCodeDebugInfo : PerfJitBase {
   uint64_t address_;
   uint64_t entry_count_;
   // Followed by entry_count_ instances of PerfJitDebugEntry.
 };
 
+struct PerfJitCodeUnwindingInfo : PerfJitBase {
+  uint64_t unwinding_size_;
+  uint64_t eh_frame_hdr_size_;
+  uint64_t mapped_size_;
+  // Followed by size_ - sizeof(PerfJitCodeUnwindingInfo) bytes of data.
+};
+
 const char PerfJitLogger::kFilenameFormatString[] = "./jit-%d.dump";
 
 // Extra padding for the PID in the filename
 const int PerfJitLogger::kFilenameBufferPadding = 16;
 
 base::LazyRecursiveMutex PerfJitLogger::file_mutex_;
 // The following static variables are protected by PerfJitLogger::file_mutex_.
 uint64_t PerfJitLogger::reference_count_ = 0;
 void* PerfJitLogger::marker_address_ = nullptr;
 uint64_t PerfJitLogger::code_index_ = 0;
@@ skipping 99 matching lines @@
   // Debug info has to be emitted first.
   if (FLAG_perf_prof_debug_info && shared != nullptr) {
     LogWriteDebugInfo(code, shared);
   }
 
   const char* code_name = name;
   uint8_t* code_pointer = reinterpret_cast<uint8_t*>(code->instruction_start());
   uint32_t code_size = code->is_crankshafted() ? code->safepoint_table_offset()
                                                : code->instruction_size();
 
+  // Unwinding info comes right after debug info.
+  if (FLAG_perf_prof) LogWriteUnwindingInfo(code);
+
   static const char string_terminator[] = "\0";
 
   PerfJitCodeLoad code_load;
   code_load.event_ = PerfJitCodeLoad::kLoad;
   code_load.size_ = sizeof(code_load) + length + 1 + code_size;
   code_load.time_stamp_ = GetTimestamp();
   code_load.process_id_ =
       static_cast<uint32_t>(base::OS::GetCurrentProcessId());
   code_load.thread_id_ = static_cast<uint32_t>(base::OS::GetCurrentThreadId());
   code_load.vma_ = 0x0;  //  Our addresses are absolute.
@@ skipping 79 matching lines @@
     entry.address_ = reinterpret_cast<uint64_t>(it.rinfo()->pc());
     entry.line_number_ = line_number;
     entry.column_ = column_offset;
     LogWriteBytes(reinterpret_cast<const char*>(&entry), sizeof(entry));
     LogWriteBytes(name_string.get(), name_length + 1);
   }
   char padding_bytes[] = "\0\0\0\0\0\0\0\0";
   LogWriteBytes(padding_bytes, padding);
 }
 
+void PerfJitLogger::LogWriteUnwindingInfo(Code* code) {
+  EhFrameHdr eh_frame_hdr(code);
+
+  PerfJitCodeUnwindingInfo unwinding_info_header;
+  unwinding_info_header.event_ = PerfJitCodeLoad::kUnwindingInfo;
+  unwinding_info_header.time_stamp_ = GetTimestamp();
+  unwinding_info_header.eh_frame_hdr_size_ = EhFrameHdr::kRecordSize;
+
+  int unwinding_info_size;

[rmcilroy, 2016/06/21 13:47:44]

nit - just use the field rather than having an extra local.

[Stefano Sanfilippo, 2016/06/23 15:23:44]

Done.

+  if (code->has_unwinding_info()) {
+    unwinding_info_size = code->unwinding_info_size();
+    unwinding_info_header.mapped_size_ = unwinding_info_size;
+  } else {
+    unwinding_info_size = EhFrameHdr::kRecordSize;
+    unwinding_info_header.mapped_size_ = 0;
+  }
+  unwinding_info_header.unwinding_size_ = unwinding_info_size;
+
+  int content_size = sizeof(unwinding_info_header) + unwinding_info_size;
+  int padding_size = ((content_size + 7) & (~7)) - content_size;

[rmcilroy, 2016/06/21 13:47:44]

Don't use literals for '7'. Can you use RoundUp here instead?

[Stefano Sanfilippo, 2016/06/23 15:23:44]

Done.

+  unwinding_info_header.size_ = content_size + padding_size;
+
+  LogWriteBytes(reinterpret_cast<const char*>(&unwinding_info_header),
+                sizeof(unwinding_info_header));
+
+  if (code->has_unwinding_info()) {
+    PatchProcedureBoundariesInEhFrame(code);

[rmcilroy, 2016/06/21 13:47:44]

You don't have any code which actually writes to the unwinding_info here. It's
impossible for me to tell what this is doing given I don't know how the
unwinding info is structured yet. Could you remove this function (and anything
relating to reading from unwind_info) from this CL and move it to one where it
actually does something (and can be tested). Let's just make this CL about
writing the dummy header and having the plumbing to pass unwind_info on code
objects.

[Stefano Sanfilippo, 2016/06/23 15:23:44]

Agreed. Done.

+
+    // The last EhFrameHdr::kRecordSize bytes were a placeholder for the header.
+    // Discard them and write the actual eh_frame_hdr (below).
+    DCHECK_GE(code->unwinding_info_size(), EhFrameHdr::kRecordSize);
+    LogWriteBytes(reinterpret_cast<const char*>(code->unwinding_info_start()),
+                  code->unwinding_info_size() - EhFrameHdr::kRecordSize);
+  }
+
+  LogWriteBytes(reinterpret_cast<const char*>(&eh_frame_hdr),
+                EhFrameHdr::kRecordSize);
+
+  char padding_bytes[] = "\0\0\0\0\0\0\0\0";
+  LogWriteBytes(padding_bytes, padding_size);
+}
+
 void PerfJitLogger::CodeMoveEvent(AbstractCode* from, Address to) {
   // Code relocation not supported.
   UNREACHABLE();
 }
 
 void PerfJitLogger::LogWriteBytes(const char* bytes, int size) {
   size_t rv = fwrite(bytes, 1, size, perf_output_handle_);
   DCHECK(static_cast<size_t>(size) == rv);
   USE(rv);
 }
@@ skipping 11 matching lines @@
   header.time_stamp_ =
       static_cast<uint64_t>(base::OS::TimeCurrentMillis() * 1000.0);
   header.flags_ = 0;
 
   LogWriteBytes(reinterpret_cast<const char*>(&header), sizeof(header));
 }
 
 #endif  // V8_OS_LINUX
 }  // namespace internal
 }  // namespace v8