[coverage] Block coverage with support for IfStatements

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 13639 matching lines @@
   shared_info->set_language_mode(lit->language_mode());
   shared_info->set_uses_arguments(lit->scope()->arguments() != NULL);
   shared_info->set_kind(lit->kind());
   if (!IsConstructable(lit->kind())) {
     shared_info->SetConstructStub(
         *shared_info->GetIsolate()->builtins()->ConstructedNonConstructable());
   }
   shared_info->set_needs_home_object(lit->scope()->NeedsHomeObject());
   shared_info->set_asm_function(lit->scope()->asm_function());
   shared_info->set_function_literal_id(lit->function_literal_id());
+  shared_info->set_coverage_info(Smi::kZero);  // Set later on bytecode-gen.
 
   // For lazy parsed functions, the following flags will be inaccurate since we
   // don't have the information yet. They're set later in
   // SetSharedFunctionFlagsFromLiteral (compiler.cc), when the function is
   // really parsed and compiled.
   if (lit->body() != nullptr) {
     shared_info->set_length(lit->function_length());
     shared_info->set_has_duplicate_parameters(lit->has_duplicate_parameters());
     shared_info->SetExpectedNofPropertiesFromEstimate(lit);
   } else {
@@ skipping 5607 matching lines @@
 // Get the number of break points.
 int BreakPointInfo::GetBreakPointCount() {
   // No break point.
   if (break_point_objects()->IsUndefined(GetIsolate())) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
+int CoverageInfo::SlotCount() const {
+  DCHECK_EQ(kFirstSlotIndex, length() % kSlotIndexCount);
+  return (length() - kFirstSlotIndex) / kSlotIndexCount;
+}
+
+int CoverageInfo::FromSourcePosition(int slot_index) const {
+  DCHECK_LT(slot_index, SlotCount());
+  const int slot_start = CoverageInfo::FirstIndexForSlot(slot_index);
+  return Smi::ToInt(get(slot_start + kSlotFromSourcePositionIndex));
+}
+
+int CoverageInfo::ToSourcePosition(int slot_index) const {
+  DCHECK_LT(slot_index, SlotCount());
+  const int slot_start = CoverageInfo::FirstIndexForSlot(slot_index);
+  return Smi::ToInt(get(slot_start + kSlotToSourcePositionIndex));
+}
+
+int CoverageInfo::BlockCount(int slot_index) const {
+  DCHECK_LT(slot_index, SlotCount());
+  const int slot_start = CoverageInfo::FirstIndexForSlot(slot_index);
+  return Smi::ToInt(get(slot_start + kSlotBlockCountIndex));
+}
+
+void CoverageInfo::InitializeSlot(int slot_index, int from_pos, int to_pos) {
+  DCHECK_LT(slot_index, SlotCount());
+  const int slot_start = CoverageInfo::FirstIndexForSlot(slot_index);
+  set(slot_start + kSlotFromSourcePositionIndex, Smi::FromInt(from_pos));
+  set(slot_start + kSlotToSourcePositionIndex, Smi::FromInt(to_pos));
+  set(slot_start + kSlotBlockCountIndex, Smi::kZero);
+}
+
+void CoverageInfo::IncrementBlockCount(int slot_index) {
+  DCHECK_LT(slot_index, SlotCount());
+  const int slot_start = CoverageInfo::FirstIndexForSlot(slot_index);
+  const int old_count = BlockCount(slot_index);
+  set(slot_start + kSlotBlockCountIndex, Smi::FromInt(old_count + 1));
+}
 
 // static
 MaybeHandle<JSDate> JSDate::New(Handle<JSFunction> constructor,
                                 Handle<JSReceiver> new_target, double tv) {
   Isolate* const isolate = constructor->GetIsolate();
   Handle<JSObject> result;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, result,
                              JSObject::New(constructor, new_target), JSDate);
   if (-DateCache::kMaxTimeInMs <= tv && tv <= DateCache::kMaxTimeInMs) {
     tv = DoubleToInteger(tv) + 0.0;
@@ skipping 1217 matching lines @@
       // not
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 }  // namespace internal
 }  // namespace v8