[debug] do not report unnecessary coverage data.

src/debug/debug-coverage.cc

 // Copyright 2017 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 "src/debug/debug-coverage.h"
 
 #include "src/base/hashmap.h"
 #include "src/deoptimizer.h"
 #include "src/frames-inl.h"
 #include "src/isolate.h"
@@ skipping 101 matching lines @@
 
   // Iterate shared function infos of every script and build a mapping
   // between source ranges and invocation counts.
   Coverage* result = new Coverage();
   Script::Iterator scripts(isolate);
   while (Script* script = scripts.Next()) {
     if (!script->IsUserJavaScript()) continue;
 
     // Create and add new script data.
     Handle<Script> script_handle(script, isolate);
-    result->emplace_back(isolate, script_handle);
+    result->emplace_back(script_handle);
     std::vector<CoverageFunction>* functions = &result->back().functions;
 
     std::vector<SharedFunctionInfo*> sorted;
 
     {
       // Sort functions by start position, from outer to inner functions.
       SharedFunctionInfo::ScriptIterator infos(script_handle);
       while (SharedFunctionInfo* info = infos.Next()) {
         sorted.push_back(info);
       }
       std::sort(sorted.begin(), sorted.end(), CompareSharedFunctionInfo);
     }
 
+    // Stack to track nested functions, referring function by index.
+    std::vector<size_t> nesting;

[caseq, 2017/03/23 00:09:56]

nit: perhaps std::vector<const CoverageFunction*> for less indirection?

[Yang, 2017/03/23 07:43:16]

I considered that. However, std::vector reallocates and copies its content when
growing the backing store. Raw pointers into the backing store will then become
invalid.

+
     // Use sorted list to reconstruct function nesting.
     for (SharedFunctionInfo* info : sorted) {
       int start = StartPosition(info);
       int end = info->end_position();
       uint32_t count = counter_map.Get(info);
       if (isolate->is_precise_binary_code_coverage() && count > 0) {
         count = info->has_reported_binary_coverage() ? 0 : 1;
         info->set_has_reported_binary_coverage(true);
       }
-      Handle<String> name(info->DebugName(), isolate);
-      functions->emplace_back(start, end, count, name);
+      // Find the correct outer function based on start position.
+      while (!nesting.empty() && functions->at(nesting.back()).end <= start) {
+        nesting.pop_back();
+      }
+      if (count > 0 ||
+          (!nesting.empty() && functions->at(nesting.back()).count > 0)) {
+        // Only include a function range if it has a non-0 count, or
+        // if it is directly nested inside a function with non-0 count.
+        Handle<String> name(info->DebugName(), isolate);
+        nesting.push_back(functions->size());
+        functions->emplace_back(start, end, count, name);
+      }
     }
+
+    // Remove entries for scripts that have no coverage.
+    if (functions->empty()) result->pop_back();
   }
   return result;
 }
 
 void Coverage::SelectMode(Isolate* isolate, debug::Coverage::Mode mode) {
   switch (mode) {
     case debug::Coverage::kBestEffort:
       isolate->SetCodeCoverageList(isolate->heap()->undefined_value());
       break;
     case debug::Coverage::kPreciseBinary:
@@ skipping 25 matching lines @@
       for (const auto& vector : vectors) list = ArrayList::Add(list, vector);
       isolate->SetCodeCoverageList(*list);
       break;
     }
   }
   isolate->set_code_coverage_mode(mode);
 }
 
 }  // namespace internal
 }  // namespace v8