[Interpreter] Add BytecodeArray class and add to SharedFunctionInfo.

BUG=v8:4280
LOG=N

Review URL: https://codereview.chromium.org/1230753004

Cr-Commit-Position: refs/heads/master@{#29843}

diff --git a/include/v8.h b/include/v8.h
index 5f4859d..084d41a 100644 (file)
--- a/include/v8.h
+++ b/include/v8.h
@@ -6946,7 +6946,7 @@ class Internals {
   static const int kNodeIsIndependentShift = 3;
   static const int kNodeIsPartiallyDependentShift = 4;
 
-  static const int kJSObjectType = 0xbe;
+  static const int kJSObjectType = 0xbf;
   static const int kFirstNonstringType = 0x80;
   static const int kOddballType = 0x83;
   static const int kForeignType = 0x87;

diff --git a/src/factory.cc b/src/factory.cc
index 77c8450..4fb5ec4 100644 (file)
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -873,6 +873,15 @@ Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
 }
 
 
+Handle<BytecodeArray> Factory::NewBytecodeArray(int length,
+                                                const byte* raw_bytecodes) {
+  DCHECK(0 <= length);
+  CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateBytecodeArray(
+                                    length, raw_bytecodes),
+                     BytecodeArray);
+}
+
+
 Handle<ExternalArray> Factory::NewExternalArray(int length,
                                                 ExternalArrayType array_type,
                                                 void* external_pointer,

diff --git a/src/factory.h b/src/factory.h
index 25b729d..478a48e 100644 (file)
--- a/src/factory.h
+++ b/src/factory.h
@@ -283,6 +283,8 @@ class Factory final {
   Handle<ByteArray> NewByteArray(int length,
                                  PretenureFlag pretenure = NOT_TENURED);
 
+  Handle<BytecodeArray> NewBytecodeArray(int length, const byte* raw_bytecodes);
+
   Handle<ExternalArray> NewExternalArray(
       int length,
       ExternalArrayType array_type,

diff --git a/src/heap-snapshot-generator.cc b/src/heap-snapshot-generator.cc
index f1bdc71..63916a2 100644 (file)
--- a/src/heap-snapshot-generator.cc
+++ b/src/heap-snapshot-generator.cc
@@ -1894,18 +1894,17 @@ bool V8HeapExplorer::IterateAndExtractSinglePass() {
 
 
 bool V8HeapExplorer::IsEssentialObject(Object* object) {
-  return object->IsHeapObject()
-      && !object->IsOddball()
-      && object != heap_->empty_byte_array()
-      && object != heap_->empty_fixed_array()
-      && object != heap_->empty_descriptor_array()
-      && object != heap_->fixed_array_map()
-      && object != heap_->cell_map()
-      && object != heap_->global_property_cell_map()
-      && object != heap_->shared_function_info_map()
-      && object != heap_->free_space_map()
-      && object != heap_->one_pointer_filler_map()
-      && object != heap_->two_pointer_filler_map();
+  return object->IsHeapObject() && !object->IsOddball() &&
+         object != heap_->empty_byte_array() &&
+         object != heap_->empty_bytecode_array() &&
+         object != heap_->empty_fixed_array() &&
+         object != heap_->empty_descriptor_array() &&
+         object != heap_->fixed_array_map() && object != heap_->cell_map() &&
+         object != heap_->global_property_cell_map() &&
+         object != heap_->shared_function_info_map() &&
+         object != heap_->free_space_map() &&
+         object != heap_->one_pointer_filler_map() &&
+         object != heap_->two_pointer_filler_map();
 }
 
 

diff --git a/src/heap/heap.cc b/src/heap/heap.cc
index ffb9f34..8fb4454 100644 (file)
--- a/src/heap/heap.cc
+++ b/src/heap/heap.cc
@@ -3001,6 +3001,7 @@ bool Heap::CreateInitialMaps() {
 
     ALLOCATE_VARSIZE_MAP(FIXED_DOUBLE_ARRAY_TYPE, fixed_double_array)
     ALLOCATE_VARSIZE_MAP(BYTE_ARRAY_TYPE, byte_array)
+    ALLOCATE_VARSIZE_MAP(BYTECODE_ARRAY_TYPE, bytecode_array)
     ALLOCATE_VARSIZE_MAP(FREE_SPACE_TYPE, free_space)
 
 #define ALLOCATE_EXTERNAL_ARRAY_MAP(Type, type, TYPE, ctype, size) \
@@ -3065,6 +3066,12 @@ bool Heap::CreateInitialMaps() {
       ByteArray* byte_array;
       if (!AllocateByteArray(0, TENURED).To(&byte_array)) return false;
       set_empty_byte_array(byte_array);
+
+      BytecodeArray* bytecode_array;
+      if (!AllocateBytecodeArray(0, nullptr).To(&bytecode_array)) {
+        return false;
+      }
+      set_empty_bytecode_array(bytecode_array);
     }
 
 #define ALLOCATE_EMPTY_EXTERNAL_ARRAY(Type, type, TYPE, ctype, size)  \
@@ -3813,6 +3820,28 @@ AllocationResult Heap::AllocateByteArray(int length, PretenureFlag pretenure) {
 }
 
 
+AllocationResult Heap::AllocateBytecodeArray(int length,
+                                             const byte* const raw_bytecodes) {
+  if (length < 0 || length > BytecodeArray::kMaxLength) {
+    v8::internal::Heap::FatalProcessOutOfMemory("invalid array length", true);
+  }
+
+  int size = BytecodeArray::SizeFor(length);
+  HeapObject* result;
+  {
+    AllocationResult allocation = AllocateRaw(size, OLD_SPACE, OLD_SPACE);
+    if (!allocation.To(&result)) return allocation;
+  }
+
+  result->set_map_no_write_barrier(bytecode_array_map());
+  BytecodeArray* instance = BytecodeArray::cast(result);
+  instance->set_length(length);
+  CopyBytes(instance->GetFirstBytecodeAddress(), raw_bytecodes, length);
+
+  return result;
+}
+
+
 void Heap::CreateFillerObjectAt(Address addr, int size) {
   if (size == 0) return;
   HeapObject* filler = HeapObject::FromAddress(addr);

diff --git a/src/heap/heap.h b/src/heap/heap.h
index 945f1bb..c981884 100644 (file)
--- a/src/heap/heap.h
+++ b/src/heap/heap.h
@@ -198,7 +198,10 @@ namespace internal {
   V(Object, weak_stack_trace_list, WeakStackTraceList)                         \
   V(Object, code_stub_context, CodeStubContext)                                \
   V(JSObject, code_stub_exports_object, CodeStubExportsObject)                 \
-  V(FixedArray, interpreter_table, InterpreterTable)
+  V(FixedArray, interpreter_table, InterpreterTable)                           \
+  V(Map, bytecode_array_map, BytecodeArrayMap)                                 \
+  V(BytecodeArray, empty_bytecode_array, EmptyBytecodeArray)
+
 
 // Entries in this list are limited to Smis and are not visited during GC.
 #define SMI_ROOT_LIST(V)                                                   \
@@ -338,6 +341,7 @@ namespace internal {
 // skip write barriers. This list is not complete and has omissions.
 #define IMMORTAL_IMMOVABLE_ROOT_LIST(V) \
   V(ByteArrayMap)                       \
+  V(BytecodeArrayMap)                   \
   V(FreeSpaceMap)                       \
   V(OnePointerFillerMap)                \
   V(TwoPointerFillerMap)                \
@@ -366,6 +370,7 @@ namespace internal {
   V(OrderedHashTableMap)                \
   V(EmptyFixedArray)                    \
   V(EmptyByteArray)                     \
+  V(EmptyBytecodeArray)                 \
   V(EmptyDescriptorArray)               \
   V(ArgumentsMarker)                    \
   V(SymbolMap)                          \
@@ -1675,6 +1680,10 @@ class Heap {
   MUST_USE_RESULT AllocationResult
       AllocateByteArray(int length, PretenureFlag pretenure = NOT_TENURED);
 
+  // Allocates a bytecode array with given contents.
+  MUST_USE_RESULT AllocationResult
+      AllocateBytecodeArray(int length, const byte* raw_bytecodes);
+
   // Copy the code and scope info part of the code object, but insert
   // the provided data as the relocation information.
   MUST_USE_RESULT AllocationResult

diff --git a/src/heap/objects-visiting-inl.h b/src/heap/objects-visiting-inl.h
index 05aa375..c1cd674 100644 (file)
--- a/src/heap/objects-visiting-inl.h
+++ b/src/heap/objects-visiting-inl.h
@@ -42,6 +42,7 @@ void StaticNewSpaceVisitor<StaticVisitor>::Initialize() {
                         int>::Visit);
 
   table_.Register(kVisitByteArray, &VisitByteArray);
+  table_.Register(kVisitBytecodeArray, &VisitBytecodeArray);
 
   table_.Register(
       kVisitSharedFunctionInfo,
@@ -147,6 +148,8 @@ void StaticMarkingVisitor<StaticVisitor>::Initialize() {
 
   table_.Register(kVisitByteArray, &DataObjectVisitor::Visit);
 
+  table_.Register(kVisitBytecodeArray, &DataObjectVisitor::Visit);
+
   table_.Register(kVisitFreeSpace, &DataObjectVisitor::Visit);
 
   table_.Register(kVisitSeqOneByteString, &DataObjectVisitor::Visit);

diff --git a/src/heap/objects-visiting.cc b/src/heap/objects-visiting.cc
index 49ce4f9..8de0da9 100644 (file)
--- a/src/heap/objects-visiting.cc
+++ b/src/heap/objects-visiting.cc
@@ -42,6 +42,9 @@ StaticVisitorBase::VisitorId StaticVisitorBase::GetVisitorId(
     case BYTE_ARRAY_TYPE:
       return kVisitByteArray;
 
+    case BYTECODE_ARRAY_TYPE:
+      return kVisitBytecodeArray;
+
     case FREE_SPACE_TYPE:
       return kVisitFreeSpace;
 

diff --git a/src/heap/objects-visiting.h b/src/heap/objects-visiting.h
index c52f066..a41cfe6 100644 (file)
--- a/src/heap/objects-visiting.h
+++ b/src/heap/objects-visiting.h
@@ -29,6 +29,7 @@ class StaticVisitorBase : public AllStatic {
   V(SeqTwoByteString)      \
   V(ShortcutCandidate)     \
   V(ByteArray)             \
+  V(BytecodeArray)         \
   V(FreeSpace)             \
   V(FixedArray)            \
   V(FixedDoubleArray)      \
@@ -320,6 +321,10 @@ class StaticNewSpaceVisitor : public StaticVisitorBase {
     return reinterpret_cast<ByteArray*>(object)->ByteArraySize();
   }
 
+  INLINE(static int VisitBytecodeArray(Map* map, HeapObject* object)) {
+    return reinterpret_cast<BytecodeArray*>(object)->BytecodeArraySize();
+  }
+
   INLINE(static int VisitFixedDoubleArray(Map* map, HeapObject* object)) {
     int length = reinterpret_cast<FixedDoubleArray*>(object)->length();
     return FixedDoubleArray::SizeFor(length);

diff --git a/src/interpreter/bytecodes.cc b/src/interpreter/bytecodes.cc
index 0ab61e1..89fcaf6 100644 (file)
--- a/src/interpreter/bytecodes.cc
+++ b/src/interpreter/bytecodes.cc
@@ -42,6 +42,12 @@ const int Bytecodes::Size(Bytecode bytecode) {
 }
 
 
+#define CHECK_SIZE(Name, arg_count) \
+  STATIC_ASSERT(arg_count <= Bytecodes::kMaximumNumberOfArguments);
+  BYTECODE_LIST(CHECK_SIZE)
+#undef CHECK_SIZE
+
+
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode) {
   return os << Bytecodes::ToString(bytecode);
 }

diff --git a/src/interpreter/bytecodes.h b/src/interpreter/bytecodes.h
index 41359b0..dc12516 100644 (file)
--- a/src/interpreter/bytecodes.h
+++ b/src/interpreter/bytecodes.h
@@ -42,11 +42,16 @@ class Bytecodes {
   // Returns the size of the bytecode including its arguments.
   static const int Size(Bytecode bytecode);
 
+  // The maximum number of arguments across all bytecodes.
+  static const int kMaximumNumberOfArguments = 1;
+
+  // Maximum size of a bytecode and its arguments.
+  static const int kMaximumSize = 1 + kMaximumNumberOfArguments;
+
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Bytecodes);
 };
 
-
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode);
 
 }  // namespace interpreter

diff --git a/src/interpreter/interpreter.h b/src/interpreter/interpreter.h
index 9af55d9..b084ec9 100644 (file)
--- a/src/interpreter/interpreter.h
+++ b/src/interpreter/interpreter.h
@@ -30,6 +30,8 @@ class Interpreter {
 
   void Initialize(bool create_heap_objects);
 
+  static bool MakeBytecode(CompilationInfo* info);
+
  private:
 // Bytecode handler generator functions.
 #define DECLARE_BYTECODE_HANDLER_GENERATOR(Name, _) \

diff --git a/src/objects-debug.cc b/src/objects-debug.cc
index 4587d2e..b68895f 100644 (file)
--- a/src/objects-debug.cc
+++ b/src/objects-debug.cc
@@ -70,6 +70,9 @@ void HeapObject::HeapObjectVerify() {
     case BYTE_ARRAY_TYPE:
       ByteArray::cast(this)->ByteArrayVerify();
       break;
+    case BYTECODE_ARRAY_TYPE:
+      BytecodeArray::cast(this)->BytecodeArrayVerify();
+      break;
     case FREE_SPACE_TYPE:
       FreeSpace::cast(this)->FreeSpaceVerify();
       break;
@@ -222,6 +225,12 @@ void ByteArray::ByteArrayVerify() {
 }
 
 
+void BytecodeArray::BytecodeArrayVerify() {
+  // TODO(oth): Walk bytecodes and immediate values to validate sanity.
+  CHECK(IsBytecodeArray());
+}
+
+
 void FreeSpace::FreeSpaceVerify() {
   CHECK(IsFreeSpace());
 }
@@ -540,6 +549,8 @@ void SharedFunctionInfo::SharedFunctionInfoVerify() {
   VerifyObjectField(kFeedbackVectorOffset);
   VerifyObjectField(kScopeInfoOffset);
   VerifyObjectField(kInstanceClassNameOffset);
+  CHECK(function_data()->IsUndefined() || IsApiFunction() ||
+        HasBuiltinFunctionId() || HasBytecodeArray());
   VerifyObjectField(kFunctionDataOffset);
   VerifyObjectField(kScriptOffset);
   VerifyObjectField(kDebugInfoOffset);

diff --git a/src/objects-inl.h b/src/objects-inl.h
index a4ca8c3..2bd8b53 100644 (file)
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -648,6 +648,7 @@ bool Object::IsNumber() const {
 
 
 TYPE_CHECKER(ByteArray, BYTE_ARRAY_TYPE)
+TYPE_CHECKER(BytecodeArray, BYTECODE_ARRAY_TYPE)
 TYPE_CHECKER(FreeSpace, FREE_SPACE_TYPE)
 
 
@@ -2924,6 +2925,7 @@ void SeededNumberDictionary::set_requires_slow_elements() {
 CAST_ACCESSOR(AccessorInfo)
 CAST_ACCESSOR(ArrayList)
 CAST_ACCESSOR(ByteArray)
+CAST_ACCESSOR(BytecodeArray)
 CAST_ACCESSOR(Cell)
 CAST_ACCESSOR(Code)
 CAST_ACCESSOR(CodeCacheHashTable)
@@ -3625,6 +3627,27 @@ Address ByteArray::GetDataStartAddress() {
 }
 
 
+byte BytecodeArray::get(int index) {
+  DCHECK(index >= 0 && index < this->length());
+  return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
+}
+
+
+void BytecodeArray::set(int index, byte value) {
+  DCHECK(index >= 0 && index < this->length());
+  WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize, value);
+}
+
+
+INT_ACCESSORS(BytecodeArray, frame_size, kFrameSizeOffset)
+INT_ACCESSORS(BytecodeArray, number_of_locals, kNumberOfLocalsOffset)
+
+
+Address BytecodeArray::GetFirstBytecodeAddress() {
+  return reinterpret_cast<Address>(this) - kHeapObjectTag + kHeaderSize;
+}
+
+
 uint8_t* ExternalUint8ClampedArray::external_uint8_clamped_pointer() {
   return reinterpret_cast<uint8_t*>(external_pointer());
 }
@@ -4113,6 +4136,9 @@ int HeapObject::SizeFromMap(Map* map) {
   if (instance_type == BYTE_ARRAY_TYPE) {
     return reinterpret_cast<ByteArray*>(this)->ByteArraySize();
   }
+  if (instance_type == BYTECODE_ARRAY_TYPE) {
+    return reinterpret_cast<BytecodeArray*>(this)->BytecodeArraySize();
+  }
   if (instance_type == FREE_SPACE_TYPE) {
     return reinterpret_cast<FreeSpace*>(this)->nobarrier_size();
   }
@@ -5515,6 +5541,17 @@ BuiltinFunctionId SharedFunctionInfo::builtin_function_id() {
 }
 
 
+bool SharedFunctionInfo::HasBytecodeArray() {
+  return function_data()->IsBytecodeArray();
+}
+
+
+BytecodeArray* SharedFunctionInfo::bytecode_array() {
+  DCHECK(HasBytecodeArray());
+  return BytecodeArray::cast(function_data());
+}
+
+
 int SharedFunctionInfo::ic_age() {
   return ICAgeBits::decode(counters());
 }

diff --git a/src/objects-printer.cc b/src/objects-printer.cc
index 2f0b1b3..f45a035 100644 (file)
--- a/src/objects-printer.cc
+++ b/src/objects-printer.cc
@@ -7,6 +7,7 @@
 #include "src/disasm.h"
 #include "src/disassembler.h"
 #include "src/heap/objects-visiting.h"
+#include "src/interpreter/bytecodes.h"
 #include "src/jsregexp.h"
 #include "src/ostreams.h"
 
@@ -72,6 +73,9 @@ void HeapObject::HeapObjectPrint(std::ostream& os) {  // NOLINT
     case BYTE_ARRAY_TYPE:
       ByteArray::cast(this)->ByteArrayPrint(os);
       break;
+    case BYTECODE_ARRAY_TYPE:
+      BytecodeArray::cast(this)->BytecodeArrayPrint(os);
+      break;
     case FREE_SPACE_TYPE:
       FreeSpace::cast(this)->FreeSpacePrint(os);
       break;
@@ -201,6 +205,11 @@ void ByteArray::ByteArrayPrint(std::ostream& os) {  // NOLINT
 }
 
 
+void BytecodeArray::BytecodeArrayPrint(std::ostream& os) {  // NOLINT
+  Disassemble(os);
+}
+
+
 void FreeSpace::FreeSpacePrint(std::ostream& os) {  // NOLINT
   os << "free space, size " << Size();
 }
@@ -817,6 +826,9 @@ void SharedFunctionInfo::SharedFunctionInfoPrint(std::ostream& os) {  // NOLINT
   os << "\n - optimized_code_map = " << Brief(optimized_code_map());
   os << "\n - feedback_vector = ";
   feedback_vector()->TypeFeedbackVectorPrint(os);
+  if (HasBytecodeArray()) {
+    os << "\n - bytecode_array = " << bytecode_array();
+  }
   os << "\n";
 }
 

diff --git a/src/objects.cc b/src/objects.cc
index 95cca34..844887b 100644 (file)
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -31,6 +31,7 @@
 #include "src/heap/objects-visiting-inl.h"
 #include "src/hydrogen.h"
 #include "src/ic/ic.h"
+#include "src/interpreter/bytecodes.h"
 #include "src/log.h"
 #include "src/lookup.h"
 #include "src/macro-assembler.h"
@@ -1273,6 +1274,9 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) {  // NOLINT
     case BYTE_ARRAY_TYPE:
       os << "<ByteArray[" << ByteArray::cast(this)->length() << "]>";
       break;
+    case BYTECODE_ARRAY_TYPE:
+      os << "<BytecodeArray[" << BytecodeArray::cast(this)->length() << "]>";
+      break;
     case FREE_SPACE_TYPE:
       os << "<FreeSpace[" << FreeSpace::cast(this)->Size() << "]>";
       break;
@@ -1499,6 +1503,7 @@ void HeapObject::IterateBody(InstanceType type, int object_size,
     case FLOAT32X4_TYPE:
     case FILLER_TYPE:
     case BYTE_ARRAY_TYPE:
+    case BYTECODE_ARRAY_TYPE:
     case FREE_SPACE_TYPE:
       break;
 
@@ -11612,6 +11617,29 @@ void Code::Disassemble(const char* name, std::ostream& os) {  // NOLINT
 #endif  // ENABLE_DISASSEMBLER
 
 
+void BytecodeArray::Disassemble(std::ostream& os) {
+  os << "Frame size " << frame_size()
+     << ", number of locals = " << number_of_locals() << "\n";
+  Vector<char> buf = Vector<char>::New(50);
+  int bytecode_size = 0;
+  for (int i = 0; i < this->length(); i += bytecode_size) {
+    interpreter::Bytecode bytecode = static_cast<interpreter::Bytecode>(get(i));
+    bytecode_size = interpreter::Bytecodes::Size(bytecode);
+
+    SNPrintF(buf, "%p : ", GetFirstBytecodeAddress() + i);
+    os << buf.start();
+    for (int j = 0; j < bytecode_size; j++) {
+      SNPrintF(buf, "%02x ", get(i + j));
+      os << buf.start();
+    }
+    for (int j = bytecode_size; j < interpreter::Bytecodes::kMaximumSize; j++) {
+      os << "   ";
+    }
+    os << bytecode;
+  }
+}
+
+
 // static
 void JSArray::Initialize(Handle<JSArray> array, int capacity, int length) {
   DCHECK(capacity >= 0);

diff --git a/src/objects.h b/src/objects.h
index d885242..caf1096 100644 (file)
--- a/src/objects.h
+++ b/src/objects.h
@@ -73,6 +73,7 @@
 //         - JSFunctionProxy
 //     - FixedArrayBase
 //       - ByteArray
+//       - BytecodeArray
 //       - FixedArray
 //         - DescriptorArray
 //         - HashTable
@@ -389,6 +390,7 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
   V(MUTABLE_HEAP_NUMBER_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 */                                 \
@@ -685,6 +687,7 @@ enum InstanceType {
   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,
@@ -951,6 +954,7 @@ template <class C> inline bool Is(Object* obj);
   V(FixedFloat64Array)             \
   V(FixedUint8ClampedArray)        \
   V(ByteArray)                     \
+  V(BytecodeArray)                 \
   V(FreeSpace)                     \
   V(JSReceiver)                    \
   V(JSObject)                      \
@@ -4233,6 +4237,53 @@ class ByteArray: public FixedArrayBase {
 };
 
 
+// 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);
+  inline void set(int index, byte value);
+
+  // Returns data start address.
+  inline Address GetFirstBytecodeAddress();
+
+  // Accessors for frame size and the number of locals
+  inline int frame_size() const;
+  inline void set_frame_size(int value);
+  inline int number_of_locals() const;
+  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 = FixedArrayBase::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 = 512 * MB;
+  // 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.
@@ -6646,8 +6697,10 @@ class SharedFunctionInfo: public HeapObject {
   DECL_ACCESSORS(instance_class_name, Object)
 
   // [function data]: This field holds some additional data for function.
-  // Currently it either has FunctionTemplateInfo to make benefit the API
-  // or Smi identifying a builtin function.
+  // Currently it has one of:
+  //  - a FunctionTemplateInfo to make benefit the API [IsApiFunction()].
+  //  - a Smi identifying a builtin function [HasBuiltinFunctionId()].
+  //  - a BytecodeArray for the interpreter [HasBytecodeArray()].
   // In the long run we don't want all functions to have this field but
   // we can fix that when we have a better model for storing hidden data
   // on objects.
@@ -6657,6 +6710,8 @@ class SharedFunctionInfo: public HeapObject {
   inline FunctionTemplateInfo* get_api_func_data();
   inline bool HasBuiltinFunctionId();
   inline BuiltinFunctionId builtin_function_id();
+  inline bool HasBytecodeArray();
+  inline BytecodeArray* bytecode_array();
 
   // [script info]: Script from which the function originates.
   DECL_ACCESSORS(script, Object)

diff --git a/src/types.cc b/src/types.cc
index 6bbf655..302ac01 100644 (file)
--- a/src/types.cc
+++ b/src/types.cc
@@ -276,6 +276,7 @@ TypeImpl<Config>::BitsetType::Lub(i::Map* map) {
     case ACCESSOR_PAIR_TYPE:
     case FIXED_ARRAY_TYPE:
     case BYTE_ARRAY_TYPE:
+    case BYTECODE_ARRAY_TYPE:
     case FOREIGN_TYPE:
     case SCRIPT_TYPE:
     case CODE_TYPE:

diff --git a/test/cctest/test-heap.cc b/test/cctest/test-heap.cc
index d31f13e..e0f758d 100644 (file)
--- a/test/cctest/test-heap.cc
+++ b/test/cctest/test-heap.cc
@@ -567,6 +567,50 @@ TEST(DeleteWeakGlobalHandle) {
 }
 
 
+TEST(BytecodeArray) {
+  static const uint8_t kRawBytes[] = {0xc3, 0x7e, 0xa5, 0x5a};
+  static const int kRawBytesSize = sizeof(kRawBytes);
+  static const int kFrameSize = 32;
+  static const int kNumberOfLocals = 20;
+
+  CcTest::InitializeVM();
+  Isolate* isolate = CcTest::i_isolate();
+  Heap* heap = isolate->heap();
+  Factory* factory = isolate->factory();
+  HandleScope scope(isolate);
+
+  // Allocate and initialize BytecodeArray
+  Handle<BytecodeArray> array =
+      factory->NewBytecodeArray(kRawBytesSize, kRawBytes);
+
+  array->set_frame_size(kFrameSize);
+  array->set_number_of_locals(kNumberOfLocals);
+
+  CHECK(array->IsBytecodeArray());
+  CHECK_EQ(array->length(), (int)sizeof(kRawBytes));
+  CHECK_LE(array->address(), array->GetFirstBytecodeAddress());
+  CHECK_GE(array->address() + array->BytecodeArraySize(),
+           array->GetFirstBytecodeAddress() + array->length());
+  for (int i = 0; i < kRawBytesSize; i++) {
+    CHECK_EQ(array->GetFirstBytecodeAddress()[i], kRawBytes[i]);
+    CHECK_EQ(array->get(i), kRawBytes[i]);
+  }
+
+  // Full garbage collection
+  heap->CollectAllGarbage();
+
+  // BytecodeArray should survive
+  CHECK_EQ(array->length(), kRawBytesSize);
+  CHECK_EQ(array->number_of_locals(), kNumberOfLocals);
+  CHECK_EQ(array->frame_size(), kFrameSize);
+
+  for (int i = 0; i < kRawBytesSize; i++) {
+    CHECK_EQ(array->get(i), kRawBytes[i]);
+    CHECK_EQ(array->GetFirstBytecodeAddress()[i], kRawBytes[i]);
+  }
+}
+
+
 static const char* not_so_random_string_table[] = {
   "abstract",
   "boolean",

diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py
index af8b6b6..f3d5d15 100644 (file)
--- a/tools/v8heapconst.py
+++ b/tools/v8heapconst.py
@@ -51,86 +51,87 @@ INSTANCE_TYPES = {
   22: "SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE",
   26: "SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE",
   128: "SYMBOL_TYPE",
+  134: "FLOAT32X4_TYPE",
   129: "MAP_TYPE",
   130: "CODE_TYPE",
   131: "ODDBALL_TYPE",
-  181: "CELL_TYPE",
-  183: "PROPERTY_CELL_TYPE",
+  182: "CELL_TYPE",
+  184: "PROPERTY_CELL_TYPE",
   132: "HEAP_NUMBER_TYPE",
   133: "MUTABLE_HEAP_NUMBER_TYPE",
-  134: "FLOAT32X4_TYPE",
   135: "FOREIGN_TYPE",
   136: "BYTE_ARRAY_TYPE",
-  137: "FREE_SPACE_TYPE",
-  138: "EXTERNAL_INT8_ARRAY_TYPE",
-  139: "EXTERNAL_UINT8_ARRAY_TYPE",
-  140: "EXTERNAL_INT16_ARRAY_TYPE",
-  141: "EXTERNAL_UINT16_ARRAY_TYPE",
-  142: "EXTERNAL_INT32_ARRAY_TYPE",
-  143: "EXTERNAL_UINT32_ARRAY_TYPE",
-  144: "EXTERNAL_FLOAT32_ARRAY_TYPE",
-  145: "EXTERNAL_FLOAT64_ARRAY_TYPE",
-  146: "EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE",
-  147: "FIXED_INT8_ARRAY_TYPE",
-  148: "FIXED_UINT8_ARRAY_TYPE",
-  149: "FIXED_INT16_ARRAY_TYPE",
-  150: "FIXED_UINT16_ARRAY_TYPE",
-  151: "FIXED_INT32_ARRAY_TYPE",
-  152: "FIXED_UINT32_ARRAY_TYPE",
-  153: "FIXED_FLOAT32_ARRAY_TYPE",
-  154: "FIXED_FLOAT64_ARRAY_TYPE",
-  155: "FIXED_UINT8_CLAMPED_ARRAY_TYPE",
-  157: "FILLER_TYPE",
-  158: "DECLARED_ACCESSOR_DESCRIPTOR_TYPE",
-  159: "DECLARED_ACCESSOR_INFO_TYPE",
-  160: "EXECUTABLE_ACCESSOR_INFO_TYPE",
-  161: "ACCESSOR_PAIR_TYPE",
-  162: "ACCESS_CHECK_INFO_TYPE",
-  163: "INTERCEPTOR_INFO_TYPE",
-  164: "CALL_HANDLER_INFO_TYPE",
-  165: "FUNCTION_TEMPLATE_INFO_TYPE",
-  166: "OBJECT_TEMPLATE_INFO_TYPE",
-  167: "SIGNATURE_INFO_TYPE",
-  168: "TYPE_SWITCH_INFO_TYPE",
-  170: "ALLOCATION_MEMENTO_TYPE",
-  169: "ALLOCATION_SITE_TYPE",
-  171: "SCRIPT_TYPE",
-  172: "CODE_CACHE_TYPE",
-  173: "POLYMORPHIC_CODE_CACHE_TYPE",
-  174: "TYPE_FEEDBACK_INFO_TYPE",
-  175: "ALIASED_ARGUMENTS_ENTRY_TYPE",
-  176: "BOX_TYPE",
-  184: "PROTOTYPE_INFO_TYPE",
-  179: "FIXED_ARRAY_TYPE",
-  156: "FIXED_DOUBLE_ARRAY_TYPE",
-  180: "SHARED_FUNCTION_INFO_TYPE",
-  182: "WEAK_CELL_TYPE",
-  188: "JS_MESSAGE_OBJECT_TYPE",
-  187: "JS_VALUE_TYPE",
-  189: "JS_DATE_TYPE",
-  190: "JS_OBJECT_TYPE",
-  191: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
-  192: "JS_GENERATOR_OBJECT_TYPE",
-  193: "JS_MODULE_TYPE",
-  194: "JS_GLOBAL_OBJECT_TYPE",
-  195: "JS_BUILTINS_OBJECT_TYPE",
-  196: "JS_GLOBAL_PROXY_TYPE",
-  197: "JS_ARRAY_TYPE",
-  198: "JS_ARRAY_BUFFER_TYPE",
-  199: "JS_TYPED_ARRAY_TYPE",
-  200: "JS_DATA_VIEW_TYPE",
-  186: "JS_PROXY_TYPE",
-  201: "JS_SET_TYPE",
-  202: "JS_MAP_TYPE",
-  203: "JS_SET_ITERATOR_TYPE",
-  204: "JS_MAP_ITERATOR_TYPE",
-  205: "JS_WEAK_MAP_TYPE",
-  206: "JS_WEAK_SET_TYPE",
-  207: "JS_REGEXP_TYPE",
-  208: "JS_FUNCTION_TYPE",
-  185: "JS_FUNCTION_PROXY_TYPE",
-  177: "DEBUG_INFO_TYPE",
-  178: "BREAK_POINT_INFO_TYPE",
+  137: "BYTECODE_ARRAY_TYPE",
+  138: "FREE_SPACE_TYPE",
+  139: "EXTERNAL_INT8_ARRAY_TYPE",
+  140: "EXTERNAL_UINT8_ARRAY_TYPE",
+  141: "EXTERNAL_INT16_ARRAY_TYPE",
+  142: "EXTERNAL_UINT16_ARRAY_TYPE",
+  143: "EXTERNAL_INT32_ARRAY_TYPE",
+  144: "EXTERNAL_UINT32_ARRAY_TYPE",
+  145: "EXTERNAL_FLOAT32_ARRAY_TYPE",
+  146: "EXTERNAL_FLOAT64_ARRAY_TYPE",
+  147: "EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE",
+  148: "FIXED_INT8_ARRAY_TYPE",
+  149: "FIXED_UINT8_ARRAY_TYPE",
+  150: "FIXED_INT16_ARRAY_TYPE",
+  151: "FIXED_UINT16_ARRAY_TYPE",
+  152: "FIXED_INT32_ARRAY_TYPE",
+  153: "FIXED_UINT32_ARRAY_TYPE",
+  154: "FIXED_FLOAT32_ARRAY_TYPE",
+  155: "FIXED_FLOAT64_ARRAY_TYPE",
+  156: "FIXED_UINT8_CLAMPED_ARRAY_TYPE",
+  158: "FILLER_TYPE",
+  159: "DECLARED_ACCESSOR_DESCRIPTOR_TYPE",
+  160: "DECLARED_ACCESSOR_INFO_TYPE",
+  161: "EXECUTABLE_ACCESSOR_INFO_TYPE",
+  162: "ACCESSOR_PAIR_TYPE",
+  163: "ACCESS_CHECK_INFO_TYPE",
+  164: "INTERCEPTOR_INFO_TYPE",
+  165: "CALL_HANDLER_INFO_TYPE",
+  166: "FUNCTION_TEMPLATE_INFO_TYPE",
+  167: "OBJECT_TEMPLATE_INFO_TYPE",
+  168: "SIGNATURE_INFO_TYPE",
+  169: "TYPE_SWITCH_INFO_TYPE",
+  171: "ALLOCATION_MEMENTO_TYPE",
+  170: "ALLOCATION_SITE_TYPE",
+  172: "SCRIPT_TYPE",
+  173: "CODE_CACHE_TYPE",
+  174: "POLYMORPHIC_CODE_CACHE_TYPE",
+  175: "TYPE_FEEDBACK_INFO_TYPE",
+  176: "ALIASED_ARGUMENTS_ENTRY_TYPE",
+  177: "BOX_TYPE",
+  185: "PROTOTYPE_INFO_TYPE",
+  180: "FIXED_ARRAY_TYPE",
+  157: "FIXED_DOUBLE_ARRAY_TYPE",
+  181: "SHARED_FUNCTION_INFO_TYPE",
+  183: "WEAK_CELL_TYPE",
+  189: "JS_MESSAGE_OBJECT_TYPE",
+  188: "JS_VALUE_TYPE",
+  190: "JS_DATE_TYPE",
+  191: "JS_OBJECT_TYPE",
+  192: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
+  193: "JS_GENERATOR_OBJECT_TYPE",
+  194: "JS_MODULE_TYPE",
+  195: "JS_GLOBAL_OBJECT_TYPE",
+  196: "JS_BUILTINS_OBJECT_TYPE",
+  197: "JS_GLOBAL_PROXY_TYPE",
+  198: "JS_ARRAY_TYPE",
+  199: "JS_ARRAY_BUFFER_TYPE",
+  200: "JS_TYPED_ARRAY_TYPE",
+  201: "JS_DATA_VIEW_TYPE",
+  187: "JS_PROXY_TYPE",
+  202: "JS_SET_TYPE",
+  203: "JS_MAP_TYPE",
+  204: "JS_SET_ITERATOR_TYPE",
+  205: "JS_MAP_ITERATOR_TYPE",
+  206: "JS_WEAK_MAP_TYPE",
+  207: "JS_WEAK_SET_TYPE",
+  208: "JS_REGEXP_TYPE",
+  209: "JS_FUNCTION_TYPE",
+  186: "JS_FUNCTION_PROXY_TYPE",
+  178: "DEBUG_INFO_TYPE",
+  179: "BREAK_POINT_INFO_TYPE",
 }
 
 # List of known V8 maps.
@@ -138,35 +139,35 @@ KNOWN_MAPS = {
   0x08081: (136, "ByteArrayMap"),
   0x080ad: (129, "MetaMap"),
   0x080d9: (131, "NullMap"),
-  0x08105: (179, "FixedArrayMap"),
+  0x08105: (180, "FixedArrayMap"),
   0x08131: (4, "OneByteInternalizedStringMap"),
-  0x0815d: (182, "WeakCellMap"),
-  0x08189: (131, "UndefinedMap"),
-  0x081b5: (132, "HeapNumberMap"),
-  0x081e1: (137, "FreeSpaceMap"),
-  0x0820d: (157, "OnePointerFillerMap"),
-  0x08239: (157, "TwoPointerFillerMap"),
-  0x08265: (131, "TheHoleMap"),
+  0x0815d: (183, "WeakCellMap"),
+  0x08189: (131, "TheHoleMap"),
+  0x081b5: (138, "FreeSpaceMap"),
+  0x081e1: (158, "OnePointerFillerMap"),
+  0x0820d: (158, "TwoPointerFillerMap"),
+  0x08239: (131, "UndefinedMap"),
+  0x08265: (132, "HeapNumberMap"),
   0x08291: (131, "BooleanMap"),
   0x082bd: (131, "UninitializedMap"),
-  0x082e9: (181, "CellMap"),
-  0x08315: (183, "GlobalPropertyCellMap"),
-  0x08341: (180, "SharedFunctionInfoMap"),
+  0x082e9: (182, "CellMap"),
+  0x08315: (184, "GlobalPropertyCellMap"),
+  0x08341: (181, "SharedFunctionInfoMap"),
   0x0836d: (133, "MutableHeapNumberMap"),
   0x08399: (134, "Float32x4Map"),
-  0x083c5: (179, "NativeContextMap"),
+  0x083c5: (180, "NativeContextMap"),
   0x083f1: (130, "CodeMap"),
-  0x0841d: (179, "ScopeInfoMap"),
-  0x08449: (179, "FixedCOWArrayMap"),
-  0x08475: (156, "FixedDoubleArrayMap"),
+  0x0841d: (180, "ScopeInfoMap"),
+  0x08449: (180, "FixedCOWArrayMap"),
+  0x08475: (157, "FixedDoubleArrayMap"),
   0x084a1: (68, "OneByteStringMap"),
-  0x084cd: (179, "FunctionContextMap"),
+  0x084cd: (180, "FunctionContextMap"),
   0x084f9: (131, "NoInterceptorResultSentinelMap"),
   0x08525: (131, "ArgumentsMarkerMap"),
   0x08551: (131, "ExceptionMap"),
   0x0857d: (131, "TerminationExceptionMap"),
-  0x085a9: (179, "HashTableMap"),
-  0x085d5: (179, "OrderedHashTableMap"),
+  0x085a9: (180, "HashTableMap"),
+  0x085d5: (180, "OrderedHashTableMap"),
   0x08601: (128, "SymbolMap"),
   0x0862d: (64, "StringMap"),
   0x08659: (69, "ConsOneByteStringMap"),
@@ -187,54 +188,55 @@ KNOWN_MAPS = {
   0x088ed: (26, "ShortExternalInternalizedStringWithOneByteDataMap"),
   0x08919: (22, "ShortExternalOneByteInternalizedStringMap"),
   0x08945: (86, "ShortExternalOneByteStringMap"),
-  0x08971: (138, "ExternalInt8ArrayMap"),
-  0x0899d: (139, "ExternalUint8ArrayMap"),
-  0x089c9: (140, "ExternalInt16ArrayMap"),
-  0x089f5: (141, "ExternalUint16ArrayMap"),
-  0x08a21: (142, "ExternalInt32ArrayMap"),
-  0x08a4d: (143, "ExternalUint32ArrayMap"),
-  0x08a79: (144, "ExternalFloat32ArrayMap"),
-  0x08aa5: (145, "ExternalFloat64ArrayMap"),
-  0x08ad1: (146, "ExternalUint8ClampedArrayMap"),
-  0x08afd: (148, "FixedUint8ArrayMap"),
-  0x08b29: (147, "FixedInt8ArrayMap"),
-  0x08b55: (150, "FixedUint16ArrayMap"),
-  0x08b81: (149, "FixedInt16ArrayMap"),
-  0x08bad: (152, "FixedUint32ArrayMap"),
-  0x08bd9: (151, "FixedInt32ArrayMap"),
-  0x08c05: (153, "FixedFloat32ArrayMap"),
-  0x08c31: (154, "FixedFloat64ArrayMap"),
-  0x08c5d: (155, "FixedUint8ClampedArrayMap"),
-  0x08c89: (179, "SloppyArgumentsElementsMap"),
-  0x08cb5: (179, "CatchContextMap"),
-  0x08ce1: (179, "WithContextMap"),
-  0x08d0d: (179, "BlockContextMap"),
-  0x08d39: (179, "ModuleContextMap"),
-  0x08d65: (179, "ScriptContextMap"),
-  0x08d91: (179, "ScriptContextTableMap"),
-  0x08dbd: (188, "JSMessageObjectMap"),
+  0x08971: (139, "ExternalInt8ArrayMap"),
+  0x0899d: (140, "ExternalUint8ArrayMap"),
+  0x089c9: (141, "ExternalInt16ArrayMap"),
+  0x089f5: (142, "ExternalUint16ArrayMap"),
+  0x08a21: (143, "ExternalInt32ArrayMap"),
+  0x08a4d: (144, "ExternalUint32ArrayMap"),
+  0x08a79: (145, "ExternalFloat32ArrayMap"),
+  0x08aa5: (146, "ExternalFloat64ArrayMap"),
+  0x08ad1: (147, "ExternalUint8ClampedArrayMap"),
+  0x08afd: (149, "FixedUint8ArrayMap"),
+  0x08b29: (148, "FixedInt8ArrayMap"),
+  0x08b55: (151, "FixedUint16ArrayMap"),
+  0x08b81: (150, "FixedInt16ArrayMap"),
+  0x08bad: (153, "FixedUint32ArrayMap"),
+  0x08bd9: (152, "FixedInt32ArrayMap"),
+  0x08c05: (154, "FixedFloat32ArrayMap"),
+  0x08c31: (155, "FixedFloat64ArrayMap"),
+  0x08c5d: (156, "FixedUint8ClampedArrayMap"),
+  0x08c89: (180, "SloppyArgumentsElementsMap"),
+  0x08cb5: (180, "CatchContextMap"),
+  0x08ce1: (180, "WithContextMap"),
+  0x08d0d: (180, "BlockContextMap"),
+  0x08d39: (180, "ModuleContextMap"),
+  0x08d65: (180, "ScriptContextMap"),
+  0x08d91: (180, "ScriptContextTableMap"),
+  0x08dbd: (189, "JSMessageObjectMap"),
   0x08de9: (135, "ForeignMap"),
-  0x08e15: (190, "NeanderMap"),
-  0x08e41: (190, "ExternalMap"),
-  0x08e6d: (170, "AllocationMementoMap"),
-  0x08e99: (169, "AllocationSiteMap"),
-  0x08ec5: (173, "PolymorphicCodeCacheMap"),
-  0x08ef1: (171, "ScriptMap"),
-  0x0907d: (176, "BoxMap"),
-  0x090a9: (160, "ExecutableAccessorInfoMap"),
-  0x090d5: (161, "AccessorPairMap"),
-  0x09101: (162, "AccessCheckInfoMap"),
-  0x0912d: (163, "InterceptorInfoMap"),
-  0x09159: (164, "CallHandlerInfoMap"),
-  0x09185: (165, "FunctionTemplateInfoMap"),
-  0x091b1: (166, "ObjectTemplateInfoMap"),
-  0x091dd: (168, "TypeSwitchInfoMap"),
-  0x09209: (172, "CodeCacheMap"),
-  0x09235: (174, "TypeFeedbackInfoMap"),
-  0x09261: (175, "AliasedArgumentsEntryMap"),
-  0x0928d: (177, "DebugInfoMap"),
-  0x092b9: (178, "BreakPointInfoMap"),
-  0x092e5: (184, "PrototypeInfoMap"),
+  0x08e15: (191, "NeanderMap"),
+  0x08e41: (191, "ExternalMap"),
+  0x08e6d: (171, "AllocationMementoMap"),
+  0x08e99: (170, "AllocationSiteMap"),
+  0x08ec5: (174, "PolymorphicCodeCacheMap"),
+  0x08ef1: (172, "ScriptMap"),
+  0x09101: (161, "ExecutableAccessorInfoMap"),
+  0x09159: (162, "AccessorPairMap"),
+  0x09209: (185, "PrototypeInfoMap"),
+  0x09839: (137, "BytecodeArrayMap"),
+  0x09865: (177, "BoxMap"),
+  0x09891: (163, "AccessCheckInfoMap"),
+  0x098bd: (164, "InterceptorInfoMap"),
+  0x098e9: (165, "CallHandlerInfoMap"),
+  0x09915: (166, "FunctionTemplateInfoMap"),
+  0x09941: (167, "ObjectTemplateInfoMap"),
+  0x0996d: (169, "TypeSwitchInfoMap"),
+  0x09999: (173, "CodeCacheMap"),
+  0x099c5: (175, "TypeFeedbackInfoMap"),
+  0x099f1: (176, "AliasedArgumentsEntryMap"),
+  0x09a1d: (178, "DebugInfoMap"),
+  0x09a49: (179, "BreakPointInfoMap"),
 }
 
 # List of known V8 objects.
@@ -242,60 +244,66 @@ KNOWN_OBJECTS = {
   ("OLD_SPACE", 0x08081): "NullValue",
   ("OLD_SPACE", 0x08091): "EmptyDescriptorArray",
   ("OLD_SPACE", 0x08099): "EmptyFixedArray",
-  ("OLD_SPACE", 0x080bd): "UndefinedValue",
-  ("OLD_SPACE", 0x080e5): "NanValue",
-  ("OLD_SPACE", 0x080f1): "TheHoleValue",
-  ("OLD_SPACE", 0x08111): "TrueValue",
-  ("OLD_SPACE", 0x08131): "FalseValue",
-  ("OLD_SPACE", 0x08155): "empty_string",
-  ("OLD_SPACE", 0x08161): "UninitializedValue",
-  ("OLD_SPACE", 0x0818d): "EmptyByteArray",
-  ("OLD_SPACE", 0x08195): "NoInterceptorResultSentinel",
-  ("OLD_SPACE", 0x081d1): "ArgumentsMarker",
-  ("OLD_SPACE", 0x081fd): "Exception",
-  ("OLD_SPACE", 0x08225): "TerminationException",
-  ("OLD_SPACE", 0x08259): "NumberStringCache",
-  ("OLD_SPACE", 0x08a61): "SingleCharacterStringCache",
-  ("OLD_SPACE", 0x08ef9): "StringSplitCache",
-  ("OLD_SPACE", 0x09301): "RegExpMultipleCache",
-  ("OLD_SPACE", 0x09709): "EmptyExternalInt8Array",
-  ("OLD_SPACE", 0x09715): "EmptyExternalUint8Array",
-  ("OLD_SPACE", 0x09721): "EmptyExternalInt16Array",
-  ("OLD_SPACE", 0x0972d): "EmptyExternalUint16Array",
-  ("OLD_SPACE", 0x09739): "EmptyExternalInt32Array",
-  ("OLD_SPACE", 0x09745): "EmptyExternalUint32Array",
-  ("OLD_SPACE", 0x09751): "EmptyExternalFloat32Array",
-  ("OLD_SPACE", 0x0975d): "EmptyExternalFloat64Array",
-  ("OLD_SPACE", 0x09769): "EmptyExternalUint8ClampedArray",
-  ("OLD_SPACE", 0x09775): "EmptyFixedUint8Array",
-  ("OLD_SPACE", 0x0977d): "EmptyFixedInt8Array",
-  ("OLD_SPACE", 0x09785): "EmptyFixedUint16Array",
-  ("OLD_SPACE", 0x0978d): "EmptyFixedInt16Array",
-  ("OLD_SPACE", 0x09795): "EmptyFixedUint32Array",
-  ("OLD_SPACE", 0x0979d): "EmptyFixedInt32Array",
-  ("OLD_SPACE", 0x097a5): "EmptyFixedFloat32Array",
-  ("OLD_SPACE", 0x097ad): "EmptyFixedFloat64Array",
-  ("OLD_SPACE", 0x097b5): "EmptyFixedUint8ClampedArray",
-  ("OLD_SPACE", 0x097bd): "InfinityValue",
-  ("OLD_SPACE", 0x097c9): "MinusZeroValue",
-  ("OLD_SPACE", 0x097d5): "MessageListeners",
-  ("OLD_SPACE", 0x097f1): "CodeStubs",
-  ("OLD_SPACE", 0x12439): "ArrayProtector",
-  ("OLD_SPACE", 0x12dfd): "KeyedLoadDummyVector",
-  ("OLD_SPACE", 0x13cc5): "NonMonomorphicCache",
-  ("OLD_SPACE", 0x14009): "PolymorphicCodeCache",
-  ("OLD_SPACE", 0x14011): "NativesSourceCache",
-  ("OLD_SPACE", 0x142d1): "ExperimentalNativesSourceCache",
-  ("OLD_SPACE", 0x14309): "ExtraNativesSourceCache",
-  ("OLD_SPACE", 0x14315): "EmptyScript",
-  ("OLD_SPACE", 0x14351): "IntrinsicFunctionNames",
-  ("OLD_SPACE", 0x233d5): "UndefinedCell",
-  ("OLD_SPACE", 0x233dd): "ObservationState",
-  ("OLD_SPACE", 0x233e9): "SymbolRegistry",
-  ("OLD_SPACE", 0x2429d): "EmptySlowElementDictionary",
-  ("OLD_SPACE", 0x242c5): "AllocationSitesScratchpad",
-  ("OLD_SPACE", 0x246cd): "WeakObjectToCodeTable",
-  ("OLD_SPACE", 0x4a5c1): "StringTable",
-  ("CODE_SPACE", 0x180c1): "JsEntryCode",
-  ("CODE_SPACE", 0x25c41): "JsConstructEntryCode",
+  ("OLD_SPACE", 0x080bd): "TheHoleValue",
+  ("OLD_SPACE", 0x080dd): "UndefinedValue",
+  ("OLD_SPACE", 0x08105): "NanValue",
+  ("OLD_SPACE", 0x08115): "TrueValue",
+  ("OLD_SPACE", 0x08135): "FalseValue",
+  ("OLD_SPACE", 0x08159): "empty_string",
+  ("OLD_SPACE", 0x08165): "UninitializedValue",
+  ("OLD_SPACE", 0x08191): "EmptyByteArray",
+  ("OLD_SPACE", 0x08199): "NoInterceptorResultSentinel",
+  ("OLD_SPACE", 0x081d5): "ArgumentsMarker",
+  ("OLD_SPACE", 0x08201): "Exception",
+  ("OLD_SPACE", 0x08229): "TerminationException",
+  ("OLD_SPACE", 0x0825d): "NumberStringCache",
+  ("OLD_SPACE", 0x08a65): "SingleCharacterStringCache",
+  ("OLD_SPACE", 0x08efd): "StringSplitCache",
+  ("OLD_SPACE", 0x09305): "RegExpMultipleCache",
+  ("OLD_SPACE", 0x0970d): "EmptyExternalInt8Array",
+  ("OLD_SPACE", 0x09719): "EmptyExternalUint8Array",
+  ("OLD_SPACE", 0x09725): "EmptyExternalInt16Array",
+  ("OLD_SPACE", 0x09731): "EmptyExternalUint16Array",
+  ("OLD_SPACE", 0x0973d): "EmptyExternalInt32Array",
+  ("OLD_SPACE", 0x09749): "EmptyExternalUint32Array",
+  ("OLD_SPACE", 0x09755): "EmptyExternalFloat32Array",
+  ("OLD_SPACE", 0x09761): "EmptyExternalFloat64Array",
+  ("OLD_SPACE", 0x0976d): "EmptyExternalUint8ClampedArray",
+  ("OLD_SPACE", 0x09779): "EmptyFixedUint8Array",
+  ("OLD_SPACE", 0x09789): "EmptyFixedInt8Array",
+  ("OLD_SPACE", 0x09799): "EmptyFixedUint16Array",
+  ("OLD_SPACE", 0x097a9): "EmptyFixedInt16Array",
+  ("OLD_SPACE", 0x097b9): "EmptyFixedUint32Array",
+  ("OLD_SPACE", 0x097c9): "EmptyFixedInt32Array",
+  ("OLD_SPACE", 0x097d9): "EmptyFixedFloat32Array",
+  ("OLD_SPACE", 0x097e9): "EmptyFixedFloat64Array",
+  ("OLD_SPACE", 0x097f9): "EmptyFixedUint8ClampedArray",
+  ("OLD_SPACE", 0x0980d): "InfinityValue",
+  ("OLD_SPACE", 0x0981d): "MinusZeroValue",
+  ("OLD_SPACE", 0x0982d): "MinusInfinityValue",
+  ("OLD_SPACE", 0x09839): "MessageListeners",
+  ("OLD_SPACE", 0x09855): "CodeStubs",
+  ("OLD_SPACE", 0x0e52d): "ArrayProtector",
+  ("OLD_SPACE", 0x0e9a1): "KeyedLoadDummyVector",
+  ("OLD_SPACE", 0x13ded): "NonMonomorphicCache",
+  ("OLD_SPACE", 0x14131): "PolymorphicCodeCache",
+  ("OLD_SPACE", 0x14139): "NativesSourceCache",
+  ("OLD_SPACE", 0x14429): "ExperimentalNativesSourceCache",
+  ("OLD_SPACE", 0x14461): "ExtraNativesSourceCache",
+  ("OLD_SPACE", 0x1446d): "CodeStubNativesSourceCache",
+  ("OLD_SPACE", 0x1448d): "EmptyScript",
+  ("OLD_SPACE", 0x144cd): "IntrinsicFunctionNames",
+  ("OLD_SPACE", 0x240e1): "UndefinedCell",
+  ("OLD_SPACE", 0x240e9): "ObservationState",
+  ("OLD_SPACE", 0x240f5): "SymbolRegistry",
+  ("OLD_SPACE", 0x24f9d): "EmptySlowElementDictionary",
+  ("OLD_SPACE", 0x24fc5): "AllocationSitesScratchpad",
+  ("OLD_SPACE", 0x253cd): "WeakObjectToCodeTable",
+  ("OLD_SPACE", 0x25461): "EmptyPropertyCell",
+  ("OLD_SPACE", 0x25471): "CodeStubContext",
+  ("OLD_SPACE", 0x2ba11): "CodeStubExportsObject",
+  ("OLD_SPACE", 0x2be89): "EmptyBytecodeArray",
+  ("OLD_SPACE", 0x594dd): "StringTable",
+  ("CODE_SPACE", 0x16341): "JsEntryCode",
+  ("CODE_SPACE", 0x26a61): "JsConstructEntryCode",
 }