[Interpreter] Add BytecodeArray class and add to SharedFunctionInfo.

src/objects.h

 // Copyright 2012 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 "src/allocation.h"
@@ skipping 55 matching lines @@
 //           - JSGlobalObject
 //           - JSBuiltinsObject
 //         - JSGlobalProxy
 //         - JSValue
 //           - JSDate
 //         - JSMessageObject
 //       - JSProxy
 //         - JSFunctionProxy
 //     - FixedArrayBase
 //       - ByteArray
+//         - BytecodeArray
 //       - FixedArray
 //         - DescriptorArray
 //         - HashTable
 //           - Dictionary
 //           - StringTable
 //           - CompilationCacheTable
 //           - CodeCacheHashTable
 //           - MapCache
 //         - OrderedHashTable
 //           - OrderedHashSet
@@ skipping 305 matching lines @@
   V(CODE_TYPE)                                                  \
   V(ODDBALL_TYPE)                                               \
   V(CELL_TYPE)                                                  \
   V(PROPERTY_CELL_TYPE)                                         \
                                                                 \
   V(HEAP_NUMBER_TYPE)                                           \
   V(MUTABLE_HEAP_NUMBER_TYPE)                                   \
   V(FLOAT32X4_TYPE)                                             \
   V(FOREIGN_TYPE)                                               \
   V(BYTE_ARRAY_TYPE)                                            \
+  V(BYTECODE_ARRAY_TYPE)                                        \
   V(FREE_SPACE_TYPE)                                            \
   /* Note: the order of these external array */                 \
   /* types is relied upon in */                                 \
   /* Object::IsExternalArray(). */                              \
   V(EXTERNAL_INT8_ARRAY_TYPE)                                   \
   V(EXTERNAL_UINT8_ARRAY_TYPE)                                  \
   V(EXTERNAL_INT16_ARRAY_TYPE)                                  \
   V(EXTERNAL_UINT16_ARRAY_TYPE)                                 \
   V(EXTERNAL_INT32_ARRAY_TYPE)                                  \
   V(EXTERNAL_UINT32_ARRAY_TYPE)                                 \
@@ skipping 276 matching lines @@
   CODE_TYPE,
   ODDBALL_TYPE,
 
   // "Data", objects that cannot contain non-map-word pointers to heap
   // objects.
   HEAP_NUMBER_TYPE,
   MUTABLE_HEAP_NUMBER_TYPE,
   FLOAT32X4_TYPE,  // FIRST_SIMD_TYPE, LAST_SIMD_TYPE
   FOREIGN_TYPE,
   BYTE_ARRAY_TYPE,
+  BYTECODE_ARRAY_TYPE,
   FREE_SPACE_TYPE,
   EXTERNAL_INT8_ARRAY_TYPE,  // FIRST_EXTERNAL_ARRAY_TYPE
   EXTERNAL_UINT8_ARRAY_TYPE,
   EXTERNAL_INT16_ARRAY_TYPE,
   EXTERNAL_UINT16_ARRAY_TYPE,
   EXTERNAL_INT32_ARRAY_TYPE,
   EXTERNAL_UINT32_ARRAY_TYPE,
   EXTERNAL_FLOAT32_ARRAY_TYPE,
   EXTERNAL_FLOAT64_ARRAY_TYPE,
   EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE,  // LAST_EXTERNAL_ARRAY_TYPE
@@ skipping 246 matching lines @@
   V(FixedInt8Array)                \
   V(FixedUint16Array)              \
   V(FixedInt16Array)               \
   V(FixedUint32Array)              \
   V(FixedInt32Array)               \
   V(FixedFloat32Array)             \
   V(FixedFloat64Array)             \
   V(FixedUint8ClampedArray)        \
   V(Float32x4)                     \
   V(ByteArray)                     \
+  V(BytecodeArray)                 \
   V(FreeSpace)                     \
   V(JSReceiver)                    \
   V(JSObject)                      \
   V(JSContextExtensionObject)      \
   V(JSGeneratorObject)             \
   V(JSModule)                      \
   V(LayoutDescriptor)              \
   V(Map)                           \
   V(DescriptorArray)               \
   V(TransitionArray)               \
@@ skipping 3280 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);
 };
 
 
+// BytecodeArray represents a sequence of interpreter bytecodes.
+class BytecodeArray : public ByteArray {
+ public:
+  static int SizeFor(int length) {
+    return OBJECT_POINTER_ALIGN(kHeaderSize + length);
+  }
+
+  // Returns data start address.
+  inline Address GetFirstBytecodeAddress();
+
+  // Accessors for frame size and offsets

[rmcilroy, 2015/07/20 11:39:46]

/s/offsets/locals count./

[oth, 2015/07/20 13:47:31]

Done.

+  inline int frame_size();
+  inline void set_frame_size(int value);
+  inline int number_of_locals();
+  inline void set_number_of_locals(int value);
+
+  DECLARE_CAST(BytecodeArray)
+
+  // Dispatched behavior.
+  inline int BytecodeArraySize() { return SizeFor(this->length()); }
+
+  DECLARE_PRINTER(BytecodeArray)
+  DECLARE_VERIFIER(BytecodeArray)
+
+  void Disassemble(std::ostream& os);
+
+  // Layout description.
+  static const int kFrameSizeOffset = ByteArray::kHeaderSize;
+  static const int kNumberOfLocalsOffset = kFrameSizeOffset + kIntSize;
+  static const int kHeaderSize = kNumberOfLocalsOffset + kIntSize;
+
+  static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);
+
+  // Maximal memory consumption for a single BytecodeArray.
+  static const int kMaxSize = ByteArray::kMaxSize;
+  // Maximal length of a single BytecodeArray.
+  static const int kMaxLength = kMaxSize - kHeaderSize;
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(BytecodeArray);
+};
+
+
 // FreeSpace are fixed-size free memory blocks used by the heap and GC.
 // They look like heap objects (are heap object tagged and have a map) so that
 // the heap remains iterable.  They have a size and a next pointer.
 // The next pointer is the raw address of the next FreeSpace object (or NULL)
 // in the free list.
 class FreeSpace: public HeapObject {
  public:
   // [size]: size of the free space including the header.
   inline int size() const;
   inline void set_size(int value);
@@ skipping 2379 matching lines @@
   // (increasingly) from crankshafted code where sufficient feedback isn't
   // available.
   DECL_ACCESSORS(feedback_vector, TypeFeedbackVector)
 
   // Unconditionally clear the type feedback vector (including vector ICs).
   void ClearTypeFeedbackInfo();
 
   // Clear the type feedback vector with a more subtle policy at GC time.
   void ClearTypeFeedbackInfoAtGCTime();
 
+  // [bytecode_array]: Interpreter bytecodes.
+  DECL_ACCESSORS(bytecode_array, BytecodeArray)
+
 #if TRACE_MAPS
   // [unique_id] - For --trace-maps purposes, an identifier that's persistent
   // even if the GC moves this SharedFunctionInfo.
   inline int unique_id() const;
   inline void set_unique_id(int value);
 #endif
 
   // [instance class name]: class name for instances.
   DECL_ACCESSORS(instance_class_name, Object)
 
@@ skipping 253 matching lines @@
   static const int kConstructStubOffset = kScopeInfoOffset + 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 kInferredNameOffset = kDebugInfoOffset + kPointerSize;
   static const int kFeedbackVectorOffset =
       kInferredNameOffset + kPointerSize;
+  static const int kBytecodeArrayOffset = kFeedbackVectorOffset + kPointerSize;
 #if TRACE_MAPS
-  static const int kUniqueIdOffset = kFeedbackVectorOffset + kPointerSize;
+  static const int kUniqueIdOffset = kBytecodeArrayOffset + kPointerSize;
   static const int kLastPointerFieldOffset = kUniqueIdOffset;
 #else
   // Just to not break the postmortrem support with conditional offsets
-  static const int kUniqueIdOffset = kFeedbackVectorOffset;
-  static const int kLastPointerFieldOffset = kFeedbackVectorOffset;
+  static const int kUniqueIdOffset = kBytecodeArrayOffset;
+  static const int kLastPointerFieldOffset = kBytecodeArrayOffset;
 #endif
 
 #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;
@@ skipping 3872 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_