[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::Collect(Isolate* isolate, bool reset_count) {
+Coverage* Coverage::CollectPrecise(Isolate* isolate) {
+  DCHECK(!isolate->is_best_effort_code_coverage());
+  Coverage* result = Collect(isolate, isolate->code_coverage_mode());
+  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, v8::debug::Coverage::kBestEffort);
+}
+
+Coverage* Coverage::Collect(Isolate* isolate,
+                            v8::debug::Coverage::Mode collectionMode) {
   SharedToCounterMap counter_map;
 
-  // Feed invocation count into the counter map.
   switch (isolate->code_coverage_mode()) {
-    case debug::Coverage::kPreciseCount: {
+    case v8::debug::Coverage::kPreciseBinary:
+    case v8::debug::Coverage::kPreciseCount: {
+      bool reset_count = collectionMode != v8::debug::Coverage::kBestEffort;
       // Feedback vectors are already listed to prevent losing them to GC.
+      DCHECK(isolate->factory()->code_coverage_list()->IsArrayList());
       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;
     }
-    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.
+    case v8::debug::Coverage::kBestEffort: {
+      DCHECK(!isolate->factory()->code_coverage_list()->IsArrayList());
+      DCHECK_EQ(v8::debug::Coverage::kBestEffort, collectionMode);
       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;
     }
   }
 
   // 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);
@@ skipping 14 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 (count != 0) {
+        switch (collectionMode) {
+          case v8::debug::Coverage::kPreciseCount:
+            break;
+          case v8::debug::Coverage::kPreciseBinary:
+            count = info->has_reported_binary_coverage() ? 0 : 1;
+            info->set_has_reported_binary_coverage(true);
+            break;
+          case v8::debug::Coverage::kBestEffort:
+            count = 1;
+            break;
+        }
+      }
       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