Serializer: serialize internal references via object visitor.

src/serialize.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_SERIALIZE_H_
 #define V8_SERIALIZE_H_
 
 #include "src/hashmap.h"
 #include "src/heap-profiler.h"
 #include "src/isolate.h"
@@ skipping 289 matching lines @@
 
   // No reservation for large object space necessary.
   static const int kNumberOfPreallocatedSpaces = LO_SPACE;
   static const int kNumberOfSpaces = LAST_SPACE + 1;
 
  protected:
   // Where the pointed-to object can be found:
   enum Where {
     kNewObject = 0,  //              Object is next in snapshot.
     // 1-7                           One per space.
-    // 0x8                           Unused.
+    // 0x8                           Used by misc. See below.
     kRootArray = 0x9,             // Object is found in root array.
     kPartialSnapshotCache = 0xa,  // Object is in the cache.
     kExternalReference = 0xb,     // Pointer to an external reference.
     kSkip = 0xc,                  // Skip n bytes.
     kBuiltin = 0xd,               // Builtin code object.
     kAttachedReference = 0xe,     // Object is described in an attached list.
     // 0xf                           Used by misc. See below.
     kBackref = 0x10,  //             Object is described relative to end.
     // 0x11-0x17                     One per space.
     kBackrefWithSkip = 0x18,  //     Object is described relative to end.
@@ skipping 27 matching lines @@
   // Misc.
   // Raw data to be copied from the snapshot.  This byte code does not advance
   // the current pointer, which is used for code objects, where we write the
   // entire code in one memcpy, then fix up stuff with kSkip and other byte
   // codes that overwrite data.
   static const int kRawData = 0x20;
   // Some common raw lengths: 0x21-0x3f.
   // These autoadvance the current pointer.
   static const int kOnePointerRawData = 0x21;
 
+  // Internal reference encoded as relative offset.
+  static const int kInternalReference = 0x08;
+
+  // 0x48, 0x88 and 0xc8 are unused.
+
   static const int kVariableRepeat = 0x60;
   // 0x61-0x6f   Repeat last word
   static const int kFixedRepeat = 0x61;
   static const int kFixedRepeatBase = kFixedRepeat - 1;
   static const int kLastFixedRepeat = 0x6f;
   static const int kMaxFixedRepeats = kLastFixedRepeat - kFixedRepeatBase;
   static int CodeForRepeats(int repeats) {
     DCHECK(repeats >= 1 && repeats <= kMaxFixedRepeats);
     return kFixedRepeatBase + repeats;
   }
@@ skipping 251 matching lines @@
         sink_(sink),
         reference_representation_(how_to_code + where_to_point),
         bytes_processed_so_far_(0),
         code_object_(o->IsCode()),
         code_has_been_output_(false) { }
     void Serialize();
     void VisitPointers(Object** start, Object** end);
     void VisitEmbeddedPointer(RelocInfo* target);
     void VisitExternalReference(Address* p);
     void VisitExternalReference(RelocInfo* rinfo);
+    void VisitInternalReference(RelocInfo* rinfo);
     void VisitCodeTarget(RelocInfo* target);
     void VisitCodeEntry(Address entry_address);
     void VisitCell(RelocInfo* rinfo);
     void VisitRuntimeEntry(RelocInfo* reloc);
     // Used for seralizing the external strings that hold the natives source.
     void VisitExternalOneByteString(
         v8::String::ExternalOneByteStringResource** resource);
     // We can't serialize a heap with external two byte strings.
     void VisitExternalTwoByteString(
         v8::String::ExternalStringResource** resource) {
@@ skipping 330 matching lines @@
       kNumInternalizedStringsOffset + kInt32Size;
   static const int kNumCodeStubKeysOffset = kNumReservationsOffset + kInt32Size;
   static const int kPayloadLengthOffset = kNumCodeStubKeysOffset + kInt32Size;
   static const int kChecksum1Offset = kPayloadLengthOffset + kInt32Size;
   static const int kChecksum2Offset = kChecksum1Offset + kInt32Size;
   static const int kHeaderSize = kChecksum2Offset + kInt32Size;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_