[debugger] add lcov support to d8.

src/d8.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
@@ skipping 12 matching lines @@
 #include "include/libplatform/libplatform.h"
 #include "include/libplatform/v8-tracing.h"
 #include "src/api.h"
 #include "src/base/cpu.h"
 #include "src/base/debug/stack_trace.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "src/base/sys-info.h"
 #include "src/basic-block-profiler.h"
+#include "src/debug/debug-coverage.h"
 #include "src/interpreter/interpreter.h"
 #include "src/list-inl.h"
 #include "src/msan.h"
 #include "src/objects-inl.h"
 #include "src/snapshot/natives.h"
 #include "src/utils.h"
 #include "src/v8.h"
 
 #ifdef V8_INSPECTOR_ENABLED
 #include "include/v8-inspector.h"
@@ skipping 1604 matching lines @@
 
   Local<Object> dispatch_counters = reinterpret_cast<i::Isolate*>(isolate)
                                         ->interpreter()
                                         ->GetDispatchCountersObject();
   std::ofstream dispatch_counters_stream(
       i::FLAG_trace_ignition_dispatches_output_file);
   dispatch_counters_stream << *String::Utf8Value(
       JSON::Stringify(context, dispatch_counters).ToLocalChecked());
 }
 
+namespace {
+void ReadRange(std::ofstream* s, std::vector<uint32_t>* lines,
+               i::Handle<i::Script> script, const i::Coverage::Range* range) {
+  // Compute line and column numbers from source position.
+  i::Script::PositionInfo start;
+  i::Script::PositionInfo end;
+  i::Script::GetPositionInfo(script, range->start, &start,
+                             i::Script::NO_OFFSET);
+  i::Script::GetPositionInfo(script, range->end, &end, i::Script::NO_OFFSET);
+  // Boundary lines could be shared between two functions with different
+  // invocation counts. Take the maximum.
+  lines->at(start.line) = std::max(lines->at(start.line), range->count);
+  lines->at(end.line) = std::max(lines->at(end.line), range->count);
+  // Invocation counts for non-boundary lines are overwritten.
+  for (int i = start.line + 1; i < end.line; i++) lines->at(i) = range->count;
+  // Note that we use 0-based line numbers. But LCOV uses 1-based line numbers.
+  if (!range->name.empty()) {
+    // Truncate UC16 characters down to Latin1.
+    std::unique_ptr<char[]> name(new char[range->name.size() + 1]);
+    for (size_t i = 0; i < range->name.size(); i++) {
+      name[i] = static_cast<char>(range->name.data()[i]);
+    }
+    name[range->name.size()] = 0;
+    *s << "FN:" << (start.line + 1) << "," << name.get() << std::endl;
+    *s << "FNDA:" << range->count << "," << name.get() << std::endl;
+  } else {
+    // Anonymous function. Use line and column as name.
+    *s << "FN:" << (start.line + 1) << ",";
+    *s << "<" << (start.line + 1) << "-" << start.column << ">" << std::endl;
+    *s << "FNDA:" << range->count << ",";
+    *s << "<" << (start.line + 1) << "-" << start.column << ">" << std::endl;
+  }
+  // Recurse over inner ranges.
+  for (const auto& inner : range->inner) ReadRange(s, lines, script, &inner);
+}
+}  // anonymous namespace
+
+// Write coverage data in LCOV format. See man page for geninfo(1).
+void Shell::WriteLcovData(v8::Isolate* isolate, const char* file) {
+  if (!file) return;
+  HandleScope handle_scope(isolate);
+  std::vector<i::Coverage::ScriptData> data =
+      i::Coverage::Collect(reinterpret_cast<i::Isolate*>(isolate));
+  std::ofstream sink(file, std::ofstream::app);
+  for (const auto& script_data : data) {
+    i::Handle<i::Script> script = script_data.script;
+    // Skip unnamed scripts.
+    if (!script->name()->IsString()) continue;
+    std::string file_name = ToSTLString(v8::Utils::ToLocal(
+        i::Handle<i::String>(i::String::cast(script->name()))));
+    // Skip scripts not backed by a file.
+    if (!std::ifstream(file_name).good()) continue;
+    sink << "SF:";
+    sink << NormalizePath(file_name, GetWorkingDirectory()) << std::endl;
+    std::vector<uint32_t> lines;
+    lines.resize(i::FixedArray::cast(script->line_ends())->length(), 0);
+    ReadRange(&sink, &lines, script, &script_data.toplevel);
+    // Write per-line coverage. LCOV uses 1-based line numbers.
+    for (size_t i = 0; i < lines.size(); i++) {
+      sink << "DA:" << (i + 1) << "," << lines[i] << std::endl;
+    }
+    sink << "end_of_record" << std::endl;
+  }
+}
 
 void Shell::OnExit(v8::Isolate* isolate) {
   if (i::FLAG_dump_counters || i::FLAG_dump_counters_nvp) {
     int number_of_counters = 0;
     for (CounterMap::Iterator i(counter_map_); i.More(); i.Next()) {
       number_of_counters++;
     }
     CounterAndKey* counters = new CounterAndKey[number_of_counters];
     int j = 0;
     for (CounterMap::Iterator i(counter_map_); i.More(); i.Next(), j++) {
@@ skipping 40 matching lines @@
           "-------------+\n");
     }
     delete [] counters;
   }
 
   delete counters_file_;
   delete counter_map_;
 }
 
 
-
 static FILE* FOpen(const char* path, const char* mode) {
 #if defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))
   FILE* result;
   if (fopen_s(&result, path, mode) == 0) {
     return result;
   } else {
     return NULL;
   }
 #else
   FILE* file = fopen(path, mode);
@@ skipping 661 matching lines @@
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--enable-tracing") == 0) {
       options.trace_enabled = true;
       argv[i] = NULL;
     } else if (strncmp(argv[i], "--trace-config=", 15) == 0) {
       options.trace_config = argv[i] + 15;
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--enable-inspector") == 0) {
       options.enable_inspector = true;
       argv[i] = NULL;
+    } else if (strncmp(argv[i], "--lcov=", 7) == 0) {
+      options.lcov_file = argv[i] + 7;
+      argv[i] = NULL;
     }
   }
 
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
 
   // Set up isolated source groups.
   options.isolate_sources = new SourceGroup[options.num_isolates];
   SourceGroup* current = options.isolate_sources;
   current->Begin(argv, 1);
   for (int i = 1; i < argc; i++) {
@@ skipping 21 matching lines @@
 
   return true;
 }
 
 
 int Shell::RunMain(Isolate* isolate, int argc, char* argv[], bool last_run) {
   for (int i = 1; i < options.num_isolates; ++i) {
     options.isolate_sources[i].StartExecuteInThread();
   }
   {
+    if (options.lcov_file) {
+      i::Coverage::EnablePrecise(reinterpret_cast<i::Isolate*>(isolate));
+    }
     HandleScope scope(isolate);
     Local<Context> context = CreateEvaluationContext(isolate);
     if (last_run && options.use_interactive_shell()) {
       // Keep using the same context in the interactive shell.
       evaluation_context_.Reset(isolate, context);
     }
     {
       Context::Scope cscope(context);
       InspectorClient inspector_client(context, options.enable_inspector);
       PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));
       options.isolate_sources[0].Execute(isolate);
     }
     DisposeModuleEmbedderData(context);
+    WriteLcovData(isolate, options.lcov_file);
   }
   CollectGarbage(isolate);
   for (int i = 1; i < options.num_isolates; ++i) {
     if (last_run) {
       options.isolate_sources[i].JoinThread();
     } else {
       options.isolate_sources[i].WaitForThread();
     }
   }
   CleanupWorkers();
@@ skipping 465 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif