[coverage] Block coverage with support for IfStatements

src/objects.h

 // 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.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 #include <memory>
 
@@ skipping 980 matching lines @@
   V(Callable)                          \
   V(CallHandlerInfo)                   \
   V(Cell)                              \
   V(Code)                              \
   V(CodeCacheHashTable)                \
   V(CompilationCacheTable)             \
   V(ConsString)                        \
   V(ConstantElementsPair)              \
   V(Constructor)                       \
   V(Context)                           \
+  V(CoverageInfo)                      \
   V(DeoptimizationInputData)           \
   V(DeoptimizationOutputData)          \
   V(DependentCode)                     \
   V(DescriptorArray)                   \
   V(Dictionary)                        \
   V(External)                          \
   V(ExternalOneByteString)             \
   V(ExternalString)                    \
   V(ExternalTwoByteString)             \
   V(FeedbackMetadata)                  \
@@ skipping 556 matching lines @@
 // Smi represents integer Numbers that can be stored in 31 bits.
 // Smis are immediate which means they are NOT allocated in the heap.
 // The this pointer has the following format: [31 bit signed int] 0
 // For long smis it has the following format:
 //     [32 bit signed int] [31 bits zero padding] 0
 // Smi stands for small integer.
 class Smi: public Object {
  public:
   // Returns the integer value.
   inline int value() const { return Internals::SmiValue(this); }
+
+  // Casts o to a Smi and returns its value.
+  static inline int ToInt(Object* o);

[rmcilroy, 2017/05/18 14:17:59]

Is this worth adding rather than just Smi::cast(o)->value() ?

[jgruber, 2017/05/22 09:43:32]

Smi::cast(o)->value()
Smi::ToInt(o)

I think the latter is way more readable (especially if the argument is not just
'o'), and I was planning on updating our entire code-base at some point in a
clean-up CL. Also a Smi::TryToInt() for the other very common pattern.

It's orthogonal to this CL though and I don't mind splitting it out.

[rmcilroy, 2017/05/22 11:08:46]

Acknowledged.

+
   inline Smi* ToUint32Smi() {
     if (value() <= 0) return Smi::kZero;
     return Smi::FromInt(static_cast<uint32_t>(value()));
   }
 
   // Convert a value to a Smi object.
   static inline Smi* FromInt(int value) {
     DCHECK(Smi::IsValid(value));
     return reinterpret_cast<Smi*>(Internals::IntToSmi(value));
   }
@@ skipping 4405 matching lines @@
   // The function is subject to debugging if a debug info is attached.
   inline bool HasDebugInfo() const;
   inline DebugInfo* GetDebugInfo() const;
 
   // A function has debug code if the compiled code has debug break slots.
   inline bool HasDebugCode() const;
 
   // [debug info]: Debug information.
   DECL_ACCESSORS(debug_info, Object)
 
+  // A function has coverage info if block coverage has been enabled and the
+  // function is user JS.
+  inline bool HasCoverageInfo() const;
+  DECL_ACCESSORS(coverage_info, Object)
+
   // Bit field containing various information collected for debugging.
   // This field is either stored on the kDebugInfo slot or inside the
   // debug info struct.
   inline int debugger_hints() const;
   inline void set_debugger_hints(int value);
 
   // Indicates that the function was created by the Function function.
   // Though it's anonymous, toString should treat it as if it had the name
   // "anonymous".  We don't set the name itself so that the system does not
   // see a binding for it.
@@ skipping 247 matching lines @@
   static const int kNameOffset = kCodeOffset + kPointerSize;
   static const int kScopeInfoOffset = kNameOffset + kPointerSize;
   static const int kOuterScopeInfoOffset = kScopeInfoOffset + kPointerSize;
   static const int kConstructStubOffset = kOuterScopeInfoOffset + kPointerSize;
   static const int kInstanceClassNameOffset =
       kConstructStubOffset + kPointerSize;
   static const int kFunctionDataOffset =
       kInstanceClassNameOffset + kPointerSize;
   static const int kScriptOffset = kFunctionDataOffset + kPointerSize;
   static const int kDebugInfoOffset = kScriptOffset + kPointerSize;
-  static const int kFunctionIdentifierOffset = kDebugInfoOffset + kPointerSize;
+  static const int kCoverageInfoOffset = kDebugInfoOffset + kPointerSize;

[rmcilroy, 2017/05/18 14:17:59]

I don't think we want to add this as a field to SFI, that will be a reasonable
memory overhead even when block coverage is turned off. Can it be added to
DebugInfo or somewhere else which is allocated on-demand?

[jgruber, 2017/05/22 09:43:32]

Ack. I discussed this with Benedikt a while ago, and he was also in favor of
moving to DebugInfo. There's still the issue that the existence of DebugInfo
currently implies the existence of breakpoints, so this assumption will need to
change.

+  static const int kFunctionIdentifierOffset =
+      kCoverageInfoOffset + kPointerSize;
   static const int kFeedbackMetadataOffset =
       kFunctionIdentifierOffset + kPointerSize;
   static const int kFunctionLiteralIdOffset =
       kFeedbackMetadataOffset + kPointerSize;
 #if TRACE_MAPS
   static const int kUniqueIdOffset = kFunctionLiteralIdOffset + kPointerSize;
   static const int kLastPointerFieldOffset = kUniqueIdOffset;
 #else
   // Just to not break the postmortrem support with conditional offsets
   static const int kUniqueIdOffset = kFunctionLiteralIdOffset;
@@ skipping 3762 matching lines @@
 
   static const int kEstimatedNofBreakPointsInFunction = 4;
 
  private:
   // Get the break point info object for a source position.
   Object* GetBreakPointInfo(int source_position);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DebugInfo);
 };
 
+// Holds information related to block code coverage.
+// More information at go/v8-designdoc-block-code-coverage.
+class CoverageInfo : public FixedArray {

[marja, 2017/05/18 11:30:17]

Please put this in a different file than objects.h. Somewhere in src/objects/ .
Maybe you want to combine with other related classes.

[jgruber, 2017/05/22 09:43:32]

Ack, thought so myself after uploading this CL. I'll move to a separate file in
objects/.

+ public:
+  int SlotCount() const;
+
+  int FromSourcePosition(int slot_index) const;
+  int ToSourcePosition(int slot_index) const;
+  int BlockCount(int slot_index) const;
+
+  void InitializeSlot(int slot_index, int from_pos, int to_pos);
+  void IncrementBlockCount(int slot_index);
+
+  static int FixedArrayLengthForSlotCount(int slot_count) {
+    return slot_count * kSlotIndexCount + kFirstSlotIndex;
+  }
+
+  DECLARE_CAST(CoverageInfo)
+
+ private:
+  static int FirstIndexForSlot(int slot_index) {
+    return kFirstSlotIndex + slot_index * kSlotIndexCount;
+  }
+
+  static const int kFirstSlotIndex = 0;
+
+  // Each slot is assigned a group of indices starting at kFirstSlotIndex.
+  // Within this group, semantics are as follows:
+  static const int kSlotFromSourcePositionIndex = 0;
+  static const int kSlotToSourcePositionIndex = 1;
+  static const int kSlotBlockCountIndex = 2;
+  static const int kSlotIndexCount = 3;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(CoverageInfo);
+};
 
 // The BreakPointInfo class holds information for break points set in a
 // function. The DebugInfo object holds a BreakPointInfo object for each code
 // position with one or more break points.
 class BreakPointInfo : public Tuple2 {
  public:
   // The position in the source for the break position.
   DECL_INT_ACCESSORS(source_position)
   // List of related JavaScript break points.
   DECL_ACCESSORS(break_point_objects, Object)
@@ skipping 153 matching lines @@
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #include "src/objects/object-macros-undef.h"
 
 #endif  // V8_OBJECTS_H_