[inspector] implemented blackboxing inside v8

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 7316 matching lines @@
   inline void set_num_literals(int value);
 
   // [start_position_and_type]: Field used to store both the source code
   // position, whether or not the function is a function expression,
   // and whether or not the function is a toplevel function. The two
   // least significants bit indicates whether the function is an
   // expression and the rest contains the source code position.
   inline int start_position_and_type() const;
   inline void set_start_position_and_type(int value);
 
+  // [end_position_and_is_blackboxed]: Field used to store both the source code
+  // position, whether or not the function is blackboxed, and whether or not the
+  // blackboxed state is computed in the two
+  // least significants bits.
+  inline int end_position_and_is_blackboxed() const;
+  inline void set_end_position_and_is_blackboxed(int value);
+
   // The function is subject to debugging if a debug info is attached.
   inline bool HasDebugInfo();
   inline DebugInfo* GetDebugInfo();
 
   // A function has debug code if the compiled code has debug break slots.
   inline bool HasDebugCode();
 
   // [debug info]: Debug information.
   DECL_ACCESSORS(debug_info, Object)
 
   // The function's name if it is non-empty, otherwise the inferred name.
   String* DebugName();
 
+  // The function is blackboxed in debugger.
+  bool DebugIsBlackboxed();
+
   // The function cannot cause any side effects.
   bool HasNoSideEffect();
 
   // Used for flags such as --hydrogen-filter.
   bool PassesFilter(const char* raw_filter);
 
   // Position of the 'function' token in the script source.
   inline int function_token_position() const;
   inline void set_function_token_position(int function_token_position);
 
   // Position of this function in the script source.
   inline int start_position() const;
   inline void set_start_position(int start_position);
 
-  // End position of this function in the script source.
-  inline int end_position() const;
-  inline void set_end_position(int end_position);
-
   // Is this function a named function expression in the source code.
   DECL_BOOLEAN_ACCESSORS(is_named_expression)
 
   // Is this function a top-level function (scripts, evals).
   DECL_BOOLEAN_ACCESSORS(is_toplevel)
 
+  // End position of this function in the script source.
+  inline int end_position() const;
+  inline void set_end_position(int end_position);
+
+  // Indicates that the function should be skipped during stepping.
+  DECL_BOOLEAN_ACCESSORS(debug_is_blackboxed)
+
+  // Indicates that |debug_is_blackboxed| has been computed and set.
+  DECL_BOOLEAN_ACCESSORS(computed_debug_is_blackboxed)
+
   // Bit field containing various information collected by the compiler to
   // drive optimization.
   inline int compiler_hints() const;
   inline void set_compiler_hints(int value);
 
   inline int ast_node_count() const;
   inline void set_ast_node_count(int count);
 
   inline int profiler_ticks() const;
   inline void set_profiler_ticks(int ticks);
@@ skipping 223 matching lines @@
 #if V8_HOST_ARCH_32_BIT
   // Smi fields.
   static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
   static const int kFormalParameterCountOffset = kLengthOffset + kPointerSize;
   static const int kExpectedNofPropertiesOffset =
       kFormalParameterCountOffset + kPointerSize;
   static const int kNumLiteralsOffset =
       kExpectedNofPropertiesOffset + kPointerSize;
   static const int kStartPositionAndTypeOffset =
       kNumLiteralsOffset + kPointerSize;
-  static const int kEndPositionOffset =
+  static const int kEndPositionAndIsBlackboxedOffset =
       kStartPositionAndTypeOffset + kPointerSize;
   static const int kFunctionTokenPositionOffset =
-      kEndPositionOffset + kPointerSize;
+      kEndPositionAndIsBlackboxedOffset + kPointerSize;
   static const int kCompilerHintsOffset =
       kFunctionTokenPositionOffset + kPointerSize;
   static const int kOptCountAndBailoutReasonOffset =
       kCompilerHintsOffset + kPointerSize;
   static const int kCountersOffset =
       kOptCountAndBailoutReasonOffset + kPointerSize;
   static const int kAstNodeCountOffset =
       kCountersOffset + kPointerSize;
   static const int kProfilerTicksOffset =
       kAstNodeCountOffset + kPointerSize;
@@ skipping 12 matching lines @@
 #if V8_TARGET_LITTLE_ENDIAN
   static const int kLengthOffset = kLastPointerFieldOffset + kPointerSize;
   static const int kFormalParameterCountOffset =
       kLengthOffset + kIntSize;
 
   static const int kExpectedNofPropertiesOffset =
       kFormalParameterCountOffset + kIntSize;
   static const int kNumLiteralsOffset =
       kExpectedNofPropertiesOffset + kIntSize;
 
-  static const int kEndPositionOffset =
+  static const int kEndPositionAndIsBlackboxedOffset =
       kNumLiteralsOffset + kIntSize;
   static const int kStartPositionAndTypeOffset =
-      kEndPositionOffset + kIntSize;
+      kEndPositionAndIsBlackboxedOffset + kIntSize;
 
   static const int kFunctionTokenPositionOffset =
       kStartPositionAndTypeOffset + kIntSize;
   static const int kCompilerHintsOffset =
       kFunctionTokenPositionOffset + kIntSize;
 
   static const int kOptCountAndBailoutReasonOffset =
       kCompilerHintsOffset + kIntSize;
   static const int kCountersOffset =
       kOptCountAndBailoutReasonOffset + kIntSize;
 
   static const int kAstNodeCountOffset =
       kCountersOffset + kIntSize;
   static const int kProfilerTicksOffset =
       kAstNodeCountOffset + kIntSize;
 
   // Total size.
   static const int kSize = kProfilerTicksOffset + kIntSize;
 
 #elif V8_TARGET_BIG_ENDIAN
   static const int kFormalParameterCountOffset =
       kLastPointerFieldOffset + kPointerSize;
   static const int kLengthOffset = kFormalParameterCountOffset + kIntSize;
 
   static const int kNumLiteralsOffset = kLengthOffset + kIntSize;
   static const int kExpectedNofPropertiesOffset = kNumLiteralsOffset + kIntSize;
 
   static const int kStartPositionAndTypeOffset =
       kExpectedNofPropertiesOffset + kIntSize;
-  static const int kEndPositionOffset = kStartPositionAndTypeOffset + kIntSize;
+  static const int kEndPositionAndIsBlackboxedOffset =
+      kStartPositionAndTypeOffset + kIntSize;
 
-  static const int kCompilerHintsOffset = kEndPositionOffset + kIntSize;
+  static const int kCompilerHintsOffset =
+      kEndPositionAndIsBlackboxedOffset + kIntSize;
   static const int kFunctionTokenPositionOffset =
       kCompilerHintsOffset + kIntSize;
 
   static const int kCountersOffset = kFunctionTokenPositionOffset + kIntSize;
   static const int kOptCountAndBailoutReasonOffset = kCountersOffset + kIntSize;
 
   static const int kProfilerTicksOffset =
       kOptCountAndBailoutReasonOffset + kIntSize;
   static const int kAstNodeCountOffset = kProfilerTicksOffset + kIntSize;
 
   // Total size.
   static const int kSize = kAstNodeCountOffset + kIntSize;
 
 #else
 #error Unknown byte ordering
 #endif  // Big endian
 #endif  // 64-bit
 
 
   static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
 
   typedef FixedBodyDescriptor<kCodeOffset,
                               kLastPointerFieldOffset + kPointerSize, kSize>
       BodyDescriptor;
   typedef FixedBodyDescriptor<kNameOffset,
                               kLastPointerFieldOffset + kPointerSize, kSize>
       BodyDescriptorWeakCode;
 
-  // Bit positions in start_position_and_type.
-  // The source code start position is in the 30 most significant bits of
-  // the start_position_and_type field.
+  // Bit positions in start_position_and_type and
+  // end_position_and_is_blackboxed.
+  // The source code position is in the 30 most significant bits of
+  // the field.
   static const int kIsNamedExpressionBit = 0;
   static const int kIsTopLevelBit = 1;
-  static const int kStartPositionShift = 2;
-  static const int kStartPositionMask = ~((1 << kStartPositionShift) - 1);
+  static const int kIsBlackboxedBit = 0;
+  static const int kIsBlackboxedComputedBit = 1;
+  static const int kPositionShift = 2;
+  static const int kPositionMask = ~((1 << kPositionShift) - 1);
 
   // Bit positions in compiler_hints.
   enum CompilerHints {
     // byte 0
     kAllowLazyCompilation,
     kMarkedForTierUp,
     kOptimizationDisabled,
     kHasDuplicateParameters,
     kNative,
     kStrictModeFunction,
@@ skipping 3963 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_