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>
 
 #include "src/assert-scope.h"
 #include "src/bailout-reason.h"
 #include "src/base/bits.h"
 #include "src/base/flags.h"
 #include "src/builtins/builtins.h"
 #include "src/checks.h"
 #include "src/elements-kind.h"
 #include "src/field-index.h"
 #include "src/flags.h"
 #include "src/list.h"
 #include "src/messages.h"
 #include "src/property-details.h"
+#include "src/source-position.h"
 #include "src/unicode-decoder.h"
 #include "src/unicode.h"
 #include "src/zone/zone.h"
 
 #if V8_TARGET_ARCH_ARM
 #include "src/arm/constants-arm.h"  // NOLINT
 #elif V8_TARGET_ARCH_ARM64
 #include "src/arm64/constants-arm64.h"  // NOLINT
 #elif V8_TARGET_ARCH_MIPS
 #include "src/mips/constants-mips.h"  // NOLINT
@@ skipping 4915 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);
 };
 
+template <class T>
+class PodArray : public ByteArray {
+ public:
+  STATIC_ASSERT(std::is_pod<T>::value);
+  T get(int index) {
+    T result;
+    copy_out(index * sizeof(T), reinterpret_cast<byte*>(&result), sizeof(T));
+    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 6473 matching lines @@
     }
     return value;
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #endif  // V8_OBJECTS_H_