Linux perf support - fix debug info.

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 153 matching lines @@
        abstract_code->kind() != AbstractCode::INTERPRETED_FUNCTION &&
        abstract_code->kind() != AbstractCode::OPTIMIZED_FUNCTION)) {
     return;
   }
 
   // We only support non-interpreted functions.
   if (!abstract_code->IsCode()) return;
   Code* code = abstract_code->GetCode();
   DCHECK(code->instruction_start() == code->address() + Code::kHeaderSize);
 
+  // Debug info has to be emitted first.
+  if (FLAG_perf_prof_debug_info) {
+    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();
 
   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.
   code_load.code_address_ = reinterpret_cast<uint64_t>(code_pointer);
   code_load.code_size_ = code_size;
   code_load.code_id_ = code_index_;
 
   code_index_++;
 
   LogWriteBytes(reinterpret_cast<const char*>(&code_load), sizeof(code_load));
   LogWriteBytes(code_name, length);
   LogWriteBytes(string_terminator, 1);
   LogWriteBytes(reinterpret_cast<const char*>(code_pointer), code_size);
-
-  if (FLAG_perf_prof_debug_info) {
-    LogWriteDebugInfo(code, shared);
-  }
 }
 
 void PerfJitLogger::LogWriteDebugInfo(Code* code, SharedFunctionInfo* shared) {
   // Compute the entry count and get the name of the script.
   uint32_t entry_count = 0;
   for (RelocIterator it(code, RelocInfo::kPositionMask); !it.done();
        it.next()) {
     entry_count++;
   }
   if (entry_count == 0) return;
@@ skipping 21 matching lines @@
 
   debug_info.event_ = PerfJitCodeLoad::kDebugInfo;
   debug_info.time_stamp_ = GetTimestamp();
   debug_info.address_ = reinterpret_cast<uint64_t>(code->instruction_start());
   debug_info.entry_count_ = entry_count;
 
   uint32_t size = sizeof(debug_info);
   // Add the sizes of fixed parts of entries.
   size += entry_count * sizeof(PerfJitDebugEntry);
   // Add the size of the name after the first entry.
-  size += static_cast<uint32_t>(name_length) + 1;
-  // Add the sizes of the links to previous name (\0xff\0).
-  size += (entry_count - 1) * 2;
+  size += (static_cast<uint32_t>(name_length) + 1) * entry_count;
 
   int padding = ((size + 7) & (~7)) - size;
 
   debug_info.size_ = size + padding;
 
   LogWriteBytes(reinterpret_cast<const char*>(&debug_info), sizeof(debug_info));
 
   int script_line_offset = script->line_offset();
   Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
 
-  bool is_first = true;
   for (RelocIterator it(code, RelocInfo::kPositionMask); !it.done();
        it.next()) {
     int position = static_cast<int>(it.rinfo()->data());
     int line_number = Script::GetLineNumber(script, position);
     // Compute column.
     int relative_line_number = line_number - script_line_offset;
     int start =
         (relative_line_number == 0)
             ? 0
             : Smi::cast(line_ends->get(relative_line_number - 1))->value() + 1;
     int column_offset = position - start;
     if (relative_line_number == 0) {
       // For the case where the code is on the same line as the script tag.
       column_offset += script->column_offset();
     }
 
     PerfJitDebugEntry entry;
     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));
-
-    if (is_first) {
-      is_first = false;
-      LogWriteBytes(name_string.get(), name_length + 1);
-    } else {
-      LogWriteBytes("\xff", 2);
-    }
+    LogWriteBytes(name_string.get(), name_length + 1);
   }
   char padding_bytes[] = "\0\0\0\0\0\0\0\0";
   LogWriteBytes(padding_bytes, padding);
 }
 
 void PerfJitLogger::CodeMoveEvent(AbstractCode* from, Address to) {
   // Code relocation not supported.
   UNREACHABLE();
 }
 
@@ skipping 16 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