[coverage] Block coverage with support for IfStatements

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 39 matching lines @@
   if (start == kNoSourcePosition) start = info->start_position();
   return start;
 }
 
 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;
 }
+
+bool CompareCoverageBlock(const CoverageBlock& a, const CoverageBlock& b) {
+  DCHECK(a.start != kNoSourcePosition && a.end != kNoSourcePosition);
+  DCHECK(b.start != kNoSourcePosition && b.end != kNoSourcePosition);
+  if (a.start == b.start) return a.end > b.end;
+  return a.start < b.start;
+}
+
+std::vector<CoverageBlock> GetSortedBlockData(Isolate* isolate,
+                                              SharedFunctionInfo* shared) {
+  DCHECK(FLAG_block_coverage);
+
+  std::vector<CoverageBlock> result;
+  Object* maybe_coverage_info = shared->coverage_info();
+
+  if (!maybe_coverage_info->IsCoverageInfo()) return result;
+  CoverageInfo* coverage_info = CoverageInfo::cast(maybe_coverage_info);
+
+  for (int i = 0; i < coverage_info->SlotCount(); i++) {
+    const int start_pos = coverage_info->FromSourcePosition(i);
+    const int until_pos = coverage_info->ToSourcePosition(i);
+    const int count = coverage_info->BlockCount(i);
+
+    DCHECK(start_pos != kNoSourcePosition);
+    DCHECK(until_pos != kNoSourcePosition);
+
+    result.emplace_back(start_pos, until_pos, count);
+  }
+
+  // Sort according to the block nesting structure.
+  std::sort(result.begin(), result.end(), CompareCoverageBlock);
+
+  return result;
+}
 }  // anonymous namespace
 
 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;
 
   switch (isolate->code_coverage_mode()) {
+    case v8::debug::Coverage::kBlockBinary:
     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();
@@ skipping 52 matching lines @@
       int end = info->end_position();
       uint32_t count = counter_map.Get(info);
       // Find the correct outer function based on start position.
       while (!nesting.empty() && functions->at(nesting.back()).end <= start) {
         nesting.pop_back();
       }
       if (count != 0) {
         switch (collectionMode) {
           case v8::debug::Coverage::kPreciseCount:
             break;
+          case v8::debug::Coverage::kBlockBinary:
           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;
         }
       }
       // 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.
       if (count != 0 ||
           (!nesting.empty() && functions->at(nesting.back()).count != 0)) {
         Handle<String> name(info->DebugName(), isolate);
         nesting.push_back(functions->size());
         functions->emplace_back(start, end, count, name);
+
+        if (FLAG_block_coverage) {
+          CoverageFunction* function = &functions->back();
+          function->blocks = GetSortedBlockData(isolate, info);
+        }
       }
     }
 
     // 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::kBlockBinary:
     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());
@@ skipping 16 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