Uniform and precise source positions for inlining

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 150 matching lines @@
 //       - Module
 //     - WeakCell
 //
 // Formats of Object*:
 //  Smi:        [31 bit signed int] 0
 //  HeapObject: [32 bit direct pointer] (4 byte aligned) | 01
 
 namespace v8 {
 namespace internal {
 
+struct InliningPosition;
+
 enum KeyedAccessStoreMode {
   STANDARD_STORE,
   STORE_TRANSITION_TO_OBJECT,
   STORE_TRANSITION_TO_DOUBLE,
   STORE_AND_GROW_NO_TRANSITION,
   STORE_AND_GROW_TRANSITION_TO_OBJECT,
   STORE_AND_GROW_TRANSITION_TO_DOUBLE,
   STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS,
   STORE_NO_TRANSITION_HANDLE_COW
 };
@@ skipping 4772 matching lines @@
 
   // Maximal memory consumption for a single ByteArray.
   static const int kMaxSize = 512 * MB;
   // Maximal length of a single ByteArray.
   static const int kMaxLength = kMaxSize - kHeaderSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ByteArray);
 };
 
+// Wrapper class for ByteArray which can store arbitrary C++ classes, as long
+// as they can be copied with memcpy.
+template <class T>
+class PodArray : public ByteArray {
+ public:
+  static Handle<PodArray<T>> New(Isolate* isolate, int length,
+                                 PretenureFlag pretenure = NOT_TENURED);
+  void copy_out(int index, T* result) {
+    ByteArray::copy_out(index * sizeof(T), reinterpret_cast<byte*>(result),
+                        sizeof(T));
+  }
+  T get(int index) {
+    T result;
+    copy_out(index, &result);
+    return result;
+  }
+  void set(int index, const T& value) {
+    copy_in(index * sizeof(T), reinterpret_cast<const byte*>(&value),
+            sizeof(T));
+  }
+  int length() { return ByteArray::length() / sizeof(T); }
+  DECLARE_CAST(PodArray<T>);
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PodArray<T>);
+};
 
 // BytecodeArray represents a sequence of interpreter bytecodes.
 class BytecodeArray : public FixedArrayBase {
  public:
   static int SizeFor(int length) {
     return OBJECT_POINTER_ALIGN(kHeaderSize + length);
   }
 
   // Setter and getter
   inline byte get(int index);
@@ skipping 212 matching lines @@
                                           elementType scalar);                \
     static inline elementType defaultValue();                                 \
   };                                                                          \
                                                                               \
   typedef FixedTypedArray<Type##ArrayTraits> Fixed##Type##Array;
 
 TYPED_ARRAYS(FIXED_TYPED_ARRAY_TRAITS)
 
 #undef FIXED_TYPED_ARRAY_TRAITS
 
-
 // DeoptimizationInputData is a fixed array used to hold the deoptimization
 // data for code generated by the Hydrogen/Lithium compiler.  It also
 // contains information about functions that were inlined.  If N different
 // functions were inlined then first N elements of the literal array will
 // contain these functions.
 //
 // It can be empty.
 class DeoptimizationInputData: public FixedArray {
  public:
   // Layout description.  Indices in the array.
   static const int kTranslationByteArrayIndex = 0;
   static const int kInlinedFunctionCountIndex = 1;
   static const int kLiteralArrayIndex = 2;
   static const int kOsrAstIdIndex = 3;
   static const int kOsrPcOffsetIndex = 4;
   static const int kOptimizationIdIndex = 5;
   static const int kSharedFunctionInfoIndex = 6;
   static const int kWeakCellCacheIndex = 7;
-  static const int kFirstDeoptEntryIndex = 8;
+  static const int kInliningPositionsIndex = 8;
+  static const int kFirstDeoptEntryIndex = 9;
 
   // Offsets of deopt entry elements relative to the start of the entry.
   static const int kAstIdRawOffset = 0;
   static const int kTranslationIndexOffset = 1;
   static const int kArgumentsStackHeightOffset = 2;
   static const int kPcOffset = 3;
   static const int kDeoptEntrySize = 4;
 
   // Simple element accessors.
 #define DECLARE_ELEMENT_ACCESSORS(name, type) \
   inline type* name();                        \
   inline void Set##name(type* value);
 
   DECLARE_ELEMENT_ACCESSORS(TranslationByteArray, ByteArray)
   DECLARE_ELEMENT_ACCESSORS(InlinedFunctionCount, Smi)
   DECLARE_ELEMENT_ACCESSORS(LiteralArray, FixedArray)
   DECLARE_ELEMENT_ACCESSORS(OsrAstId, Smi)
   DECLARE_ELEMENT_ACCESSORS(OsrPcOffset, Smi)
   DECLARE_ELEMENT_ACCESSORS(OptimizationId, Smi)
   DECLARE_ELEMENT_ACCESSORS(SharedFunctionInfo, Object)
   DECLARE_ELEMENT_ACCESSORS(WeakCellCache, Object)
+  DECLARE_ELEMENT_ACCESSORS(InliningPositions, PodArray<InliningPosition>)
 
 #undef DECLARE_ELEMENT_ACCESSORS
 
   // Accessors for elements of the ith deoptimization entry.
 #define DECLARE_ENTRY_ACCESSORS(name, type) \
   inline type* name(int i);                 \
   inline void Set##name(int i, type* value);
 
   DECLARE_ENTRY_ACCESSORS(AstIdRaw, Smi)
   DECLARE_ENTRY_ACCESSORS(TranslationIndex, Smi)
@@ skipping 21 matching lines @@
 
  private:
   static int IndexForEntry(int i) {
     return kFirstDeoptEntryIndex + (i * kDeoptEntrySize);
   }
 
 
   static int LengthFor(int entry_count) { return IndexForEntry(entry_count); }
 };
 
-
 // DeoptimizationOutputData is a fixed array used to hold the deoptimization
 // data for code generated by the full compiler.
 // The format of the these objects is
 //   [i * 2]: Ast ID for ith deoptimization.
 //   [i * 2 + 1]: PC and state of ith deoptimization
 class DeoptimizationOutputData: public FixedArray {
  public:
   inline int DeoptPoints();
 
   inline BailoutId AstId(int index);
@@ skipping 1865 matching lines @@
   // Set eval origin for stack trace formatting.
   static void SetEvalOrigin(Handle<Script> script,
                             Handle<SharedFunctionInfo> outer,
                             int eval_position);
   // Retrieve source position from where eval was called.
   int GetEvalPosition();
 
   // Init line_ends array with source code positions of line ends.
   static void InitLineEnds(Handle<Script> script);
 
-  // Convert code offset into column number.
-  static int GetColumnNumber(Handle<Script> script, int code_offset);
-
-  // Convert code offset into (zero-based) line number.
-  // The non-handlified version does not allocate, but may be much slower.
-  static int GetLineNumber(Handle<Script> script, int code_offset);
-  int GetLineNumber(int code_pos);
-
   // Carries information about a source position.
   struct PositionInfo {
     PositionInfo() : line(-1), column(-1), line_start(-1), line_end(-1) {}
 
     int line;        // Zero-based line number.
     int column;      // Zero-based column number.
     int line_start;  // Position of first character in line.
-    int line_end;    // Position of last (non-linebreak) character in line.
+    int line_end;    // Position of final linebreak character in line.
   };
 
   // Specifies whether to add offsets to position infos.
   enum OffsetFlag { NO_OFFSET = 0, WITH_OFFSET = 1 };
 
   // Retrieves information about the given position, optionally with an offset.
   // Returns false on failure, and otherwise writes into the given info object
   // on success.
+  // The non-handlified version does not allocate, but may be much slower.
+  static bool GetPositionInfo(Handle<Script> script, int position,
+                              PositionInfo* info, OffsetFlag offset_flag);
   bool GetPositionInfo(int position, PositionInfo* info,
                        OffsetFlag offset_flag);
 
+  // Wrappers for GetPositionInfo
+  static int GetColumnNumber(Handle<Script> script, int code_offset);

[vogelheim, 2016/11/07 17:53:27]

The static instances get GetPositionInfo, GetColumnNumber and GetLineNumber look
like some rather gratuitous code duplication. Is there a reason why we can't
just call script->GetXXXX instead? If something is missing, can we make the
non-static members do that additional work instead?

[Tobias Tebbi, 2016/11/08 10:29:07]

The reason is that the non-static methods are not allocating, but may be slower
because the cannot initialize the line ends array. So handlified callsites
should use the handlified version for performace, while unhandlified callsites
have to resort to the non-static methods. I will clearify the above comment.

+  int GetColumnNumber(int code_pos);

[vogelheim, 2016/11/07 17:53:27]

const method?

[Also GetLineNumber below. And I get GetPositionInfo above..

It looks like making GetPositionInfo const would require ends() to be const,
which requires the underlying member to be mutable. Not sure if any of this is
worth the effort, though. You decide.]

[Tobias Tebbi, 2016/11/08 10:29:07]

Since the underlying member is not even a C++ member, this would require const
casting. Also, the C++11 lib spec requires const methods to be thread-safe
(http://stackoverflow.com/questions/14127379/does-const-mean-thread-safe-in-c11),
so mutable should only be used on locked objects. On the other hand, this update
of a cache should even be a case of lock-free thread safety... And I am not sure
if this applies to V8 at all.

+  static int GetLineNumber(Handle<Script> script, int code_offset);
+  int GetLineNumber(int code_pos);
+
   // Get the JS object wrapping the given script; create it if none exists.
   static Handle<JSObject> GetWrapper(Handle<Script> script);
 
   // Look through the list of existing shared function infos to find one
   // that matches the function literal.  Return empty handle if not found.
   MaybeHandle<SharedFunctionInfo> FindSharedFunctionInfo(FunctionLiteral* fun);
 
   // Iterate over all script objects on the heap.
   class Iterator {
    public:
@@ skipping 22 matching lines @@
   static const int kEvalFromPositionOffset =
       kEvalFromSharedOffset + kPointerSize;
   static const int kSharedFunctionInfosOffset =
       kEvalFromPositionOffset + kPointerSize;
   static const int kFlagsOffset = kSharedFunctionInfosOffset + kPointerSize;
   static const int kSourceUrlOffset = kFlagsOffset + kPointerSize;
   static const int kSourceMappingUrlOffset = kSourceUrlOffset + kPointerSize;
   static const int kSize = kSourceMappingUrlOffset + kPointerSize;
 
  private:
-  int GetLineNumberWithArray(int code_pos);
-
   // Bit positions in the flags field.
   static const int kCompilationTypeBit = 0;
   static const int kCompilationStateBit = 1;
   static const int kHideSourceBit = 2;
   static const int kOriginOptionsShift = 3;
   static const int kOriginOptionsSize = 3;
   static const int kOriginOptionsMask = ((1 << kOriginOptionsSize) - 1)
                                         << kOriginOptionsShift;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Script);
@@ skipping 4525 matching lines @@
     }
     return value;
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #endif  // V8_OBJECTS_H_