[debug] introduce precise binary code coverage.

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 41 matching lines @@
 }
 
 bool CompareSharedFunctionInfo(SharedFunctionInfo* a, SharedFunctionInfo* b) {
   int a_start = StartPosition(a);
   int b_start = StartPosition(b);
   if (a_start == b_start) return a->end_position() > b->end_position();
   return a_start < b_start;
 }
 }  // anonymous namespace
 
+Coverage* Coverage::CollectPrecise(Isolate* isolate) {
+  DCHECK(!isolate->is_best_effort_code_coverage());
+  Coverage* result = Collect(isolate, true);
+  if (isolate->is_precise_binary_code_coverage()) {
+    // We do not have to hold onto feedback vectors for invocations we already
+    // reported. So we can reset the list.
+    isolate->SetCodeCoverageList(*ArrayList::New(isolate, 0));
+  }
+  return result;
+}
+
+Coverage* Coverage::CollectBestEffort(Isolate* isolate) {
+  return Collect(isolate, false);
+}
+
 Coverage* Coverage::Collect(Isolate* isolate, bool reset_count) {
   SharedToCounterMap counter_map;
 
-  // Feed invocation count into the counter map.
-  switch (isolate->code_coverage_mode()) {
-    case debug::Coverage::kPreciseCount: {
-      // Feedback vectors are already listed to prevent losing them to GC.

[jgruber, 2017/03/21 16:54:34]

Nit: These comments were pretty useful. I also prefer the old
switch(code_coverage_mode) structure of this function.

-      Handle<ArrayList> list =
-          Handle<ArrayList>::cast(isolate->factory()->code_coverage_list());
-      for (int i = 0; i < list->Length(); i++) {
-        FeedbackVector* vector = FeedbackVector::cast(list->Get(i));
-        SharedFunctionInfo* shared = vector->shared_function_info();
-        DCHECK(shared->IsSubjectToDebugging());
-        uint32_t count = static_cast<uint32_t>(vector->invocation_count());
-        if (reset_count) vector->clear_invocation_count();
-        counter_map.Add(shared, count);
-      }
-      break;
+  if (isolate->factory()->code_coverage_list()->IsArrayList()) {
+    DCHECK(!isolate->is_best_effort_code_coverage());
+    Handle<ArrayList> list =
+        Handle<ArrayList>::cast(isolate->factory()->code_coverage_list());
+    for (int i = 0; i < list->Length(); i++) {
+      FeedbackVector* vector = FeedbackVector::cast(list->Get(i));
+      SharedFunctionInfo* shared = vector->shared_function_info();
+      DCHECK(shared->IsSubjectToDebugging());
+      uint32_t count = static_cast<uint32_t>(vector->invocation_count());
+      if (reset_count) vector->clear_invocation_count();

[jgruber, 2017/03/21 16:54:34]

If counts are reset iff collecting precise coverage, maybe we can remove the
reset_count parameter.

[Yang, 2017/03/22 06:46:00]

One use case I expect is that precise coverage has been enabled, but we collect
best effort coverage. In that case we have the ArrayList, but do not want to
reset the invocation counts.

But if we are in best effort mode, we definitely should not reset the invocation
count.

+      counter_map.Add(shared, count);
     }
-    case debug::Coverage::kBestEffort: {
-      // Iterate the heap to find all feedback vectors and accumulate the
-      // invocation counts into the map for each shared function info.
-      HeapIterator heap_iterator(isolate->heap());
-      while (HeapObject* current_obj = heap_iterator.next()) {
-        if (!current_obj->IsFeedbackVector()) continue;
-        FeedbackVector* vector = FeedbackVector::cast(current_obj);
-        SharedFunctionInfo* shared = vector->shared_function_info();
-        if (!shared->IsSubjectToDebugging()) continue;
-        uint32_t count = static_cast<uint32_t>(vector->invocation_count());
-        if (reset_count) vector->clear_invocation_count();
-        counter_map.Add(shared, count);
-      }
-      break;
+  } else {
+    DCHECK(isolate->is_best_effort_code_coverage());
+    HeapIterator heap_iterator(isolate->heap());
+    while (HeapObject* current_obj = heap_iterator.next()) {
+      if (!current_obj->IsFeedbackVector()) continue;
+      FeedbackVector* vector = FeedbackVector::cast(current_obj);
+      SharedFunctionInfo* shared = vector->shared_function_info();
+      if (!shared->IsSubjectToDebugging()) continue;
+      uint32_t count = static_cast<uint32_t>(vector->invocation_count());
+      if (reset_count) vector->clear_invocation_count();
+      counter_map.Add(shared, count);
     }
   }
 
   // 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;
 
@@ skipping 11 matching lines @@
         sorted.push_back(info);
       }
       std::sort(sorted.begin(), sorted.end(), CompareSharedFunctionInfo);
     }
 
     // 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);
     }
   }
   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:
     case debug::Coverage::kPreciseCount: {
       HandleScope scope(isolate);
       // Remove all optimized function. Optimized and inlined functions do not
       // increment invocation count.
       Deoptimizer::DeoptimizeAll(isolate);
       // Collect existing feedback vectors.
       std::vector<Handle<FeedbackVector>> vectors;
       {
         HeapIterator heap_iterator(isolate->heap());
         while (HeapObject* current_obj = heap_iterator.next()) {
-          if (!current_obj->IsFeedbackVector()) continue;
-          FeedbackVector* vector = FeedbackVector::cast(current_obj);
-          SharedFunctionInfo* shared = vector->shared_function_info();
-          if (!shared->IsSubjectToDebugging()) continue;
-          vectors.emplace_back(vector, isolate);
+          if (current_obj->IsSharedFunctionInfo()) {
+            SharedFunctionInfo* shared = SharedFunctionInfo::cast(current_obj);
+            shared->set_has_reported_binary_coverage(false);
+          } else if (current_obj->IsFeedbackVector()) {
+            FeedbackVector* vector = FeedbackVector::cast(current_obj);
+            SharedFunctionInfo* shared = vector->shared_function_info();
+            if (!shared->IsSubjectToDebugging()) continue;
+            vectors.emplace_back(vector, isolate);
+          }
         }
       }
       // Add collected feedback vectors to the root list lest we lose them to
       // GC.
       Handle<ArrayList> list =
           ArrayList::New(isolate, static_cast<int>(vectors.size()));
       for (const auto& vector : vectors) list = ArrayList::Add(list, vector);
       isolate->SetCodeCoverageList(*list);
       break;
     }
   }
   isolate->set_code_coverage_mode(mode);
 }
 
 }  // namespace internal
 }  // namespace v8