[serializer] prepare attached references for general use.

src/snapshot/serializer.cc

 // Copyright 2016 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.
 
 #include "src/snapshot/serializer.h"
 
 #include "src/macro-assembler.h"
 #include "src/snapshot/natives.h"
 
 namespace v8 {
@@ skipping 106 matching lines @@
       out->Add(SerializedData::Reservation(pending_chunk_[i]));
     }
     out->last().mark_as_last();
   }
 
   out->Add(SerializedData::Reservation(large_objects_total_size_));
   out->last().mark_as_last();
 }
 
 #ifdef DEBUG
-bool Serializer::BackReferenceIsAlreadyAllocated(BackReference reference) {
-  DCHECK(reference.is_valid());
-  DCHECK(!reference.is_source());
-  DCHECK(!reference.is_global_proxy());
+bool Serializer::BackReferenceIsAlreadyAllocated(
+    SerializerReference reference) {
+  DCHECK(reference.is_back_reference());
   AllocationSpace space = reference.space();
   int chunk_index = reference.chunk_index();
   if (space == LO_SPACE) {
     return chunk_index == 0 &&
            reference.large_object_index() < seen_large_objects_index_;
   } else if (chunk_index == completed_chunks_[space].length()) {
     return reference.chunk_offset() < pending_chunk_[space];
   } else {
     return chunk_index < completed_chunks_[space].length() &&
            reference.chunk_offset() < completed_chunks_[space][chunk_index];
@@ skipping 15 matching lines @@
       }
       if (skip != 0) {
         sink_->Put(kHotObjectWithSkip + index, "HotObjectWithSkip");
         sink_->PutInt(skip, "HotObjectSkipDistance");
       } else {
         sink_->Put(kHotObject + index, "HotObject");
       }
       return true;
     }
   }
-  BackReference back_reference = back_reference_map_.Lookup(obj);
-  if (back_reference.is_valid()) {
+  SerializerReference reference = reference_map_.Lookup(obj);
+  if (reference.is_valid()) {
     // Encode the location of an already deserialized object in order to write
     // its location into a later object.  We can encode the location as an
     // offset fromthe start of the deserialized objects or as an offset
     // backwards from thecurrent allocation pointer.
-    if (back_reference.is_source()) {
+    if (reference.is_attached_reference()) {
       FlushSkip(skip);
-      if (FLAG_trace_serializer) PrintF(" Encoding source object\n");
-      DCHECK(how_to_code == kPlain && where_to_point == kStartOfObject);
-      sink_->Put(kAttachedReference + kPlain + kStartOfObject, "Source");
-      sink_->PutInt(kSourceObjectReference, "kSourceObjectReference");
-    } else if (back_reference.is_global_proxy()) {
-      FlushSkip(skip);
-      if (FLAG_trace_serializer) PrintF(" Encoding global proxy\n");
-      DCHECK(how_to_code == kPlain && where_to_point == kStartOfObject);
-      sink_->Put(kAttachedReference + kPlain + kStartOfObject, "Global Proxy");
-      sink_->PutInt(kGlobalProxyReference, "kGlobalProxyReference");
+      if (FLAG_trace_serializer) {
+        PrintF(" Encoding attached reference %d\n",
+               reference.attached_reference_index());
+      }
+      PutAttachedReference(reference, how_to_code, where_to_point);
     } else {
+      DCHECK(reference.is_back_reference());
       if (FLAG_trace_serializer) {
         PrintF(" Encoding back reference to: ");
         obj->ShortPrint();
         PrintF("\n");
       }
 
       PutAlignmentPrefix(obj);
-      AllocationSpace space = back_reference.space();
+      AllocationSpace space = reference.space();
       if (skip == 0) {
         sink_->Put(kBackref + how_to_code + where_to_point + space, "BackRef");
       } else {
         sink_->Put(kBackrefWithSkip + how_to_code + where_to_point + space,
                    "BackRefWithSkip");
         sink_->PutInt(skip, "BackRefSkipDistance");
       }
-      PutBackReference(obj, back_reference);
+      PutBackReference(obj, reference);
     }
     return true;
   }
   return false;
 }
 
 void Serializer::PutRoot(int root_index, HeapObject* object,
                          SerializerDeserializer::HowToCode how_to_code,
                          SerializerDeserializer::WhereToPoint where_to_point,
                          int skip) {
@@ skipping 18 matching lines @@
     sink_->PutInt(root_index, "root_index");
   }
 }
 
 void Serializer::PutSmi(Smi* smi) {
   sink_->Put(kOnePointerRawData, "Smi");
   byte* bytes = reinterpret_cast<byte*>(&smi);
   for (int i = 0; i < kPointerSize; i++) sink_->Put(bytes[i], "Byte");
 }
 
-void Serializer::PutBackReference(HeapObject* object, BackReference reference) {
+void Serializer::PutBackReference(HeapObject* object,
+                                  SerializerReference reference) {
   DCHECK(BackReferenceIsAlreadyAllocated(reference));
-  sink_->PutInt(reference.reference(), "BackRefValue");
+  sink_->PutInt(reference.back_reference(), "BackRefValue");
   hot_objects_.Add(object);
 }
 
+void Serializer::PutAttachedReference(SerializerReference reference,
+                                      HowToCode how_to_code,
+                                      WhereToPoint where_to_point) {
+  DCHECK(reference.is_attached_reference());
+  DCHECK((how_to_code == kPlain && where_to_point == kStartOfObject) ||
+         (how_to_code == kPlain && where_to_point == kInnerPointer) ||
+         (how_to_code == kFromCode && where_to_point == kInnerPointer));
+  sink_->Put(kAttachedReference + how_to_code + where_to_point, "AttachedRef");
+  sink_->PutInt(reference.attached_reference_index(), "AttachedRefIndex");
+}
+
 int Serializer::PutAlignmentPrefix(HeapObject* object) {
   AllocationAlignment alignment = object->RequiredAlignment();
   if (alignment != kWordAligned) {
     DCHECK(1 <= alignment && alignment <= 3);
     byte prefix = (kAlignmentPrefix - 1) + alignment;
     sink_->Put(prefix, "Alignment");
     return Heap::GetMaximumFillToAlign(alignment);
   }
   return 0;
 }
 
-BackReference Serializer::AllocateLargeObject(int size) {
+SerializerReference Serializer::AllocateLargeObject(int size) {
   // Large objects are allocated one-by-one when deserializing. We do not
   // have to keep track of multiple chunks.
   large_objects_total_size_ += size;
-  return BackReference::LargeObjectReference(seen_large_objects_index_++);
+  return SerializerReference::LargeObjectReference(seen_large_objects_index_++);
 }
 
-BackReference Serializer::Allocate(AllocationSpace space, int size) {
+SerializerReference Serializer::Allocate(AllocationSpace space, int size) {
   DCHECK(space >= 0 && space < kNumberOfPreallocatedSpaces);
   DCHECK(size > 0 && size <= static_cast<int>(max_chunk_size(space)));
   uint32_t new_chunk_size = pending_chunk_[space] + size;
   if (new_chunk_size > max_chunk_size(space)) {
     // The new chunk size would not fit onto a single page. Complete the
     // current chunk and start a new one.
     sink_->Put(kNextChunk, "NextChunk");
     sink_->Put(space, "NextChunkSpace");
     completed_chunks_[space].Add(pending_chunk_[space]);
-    DCHECK_LE(completed_chunks_[space].length(), BackReference::kMaxChunkIndex);
     pending_chunk_[space] = 0;
     new_chunk_size = size;
   }
   uint32_t offset = pending_chunk_[space];
   pending_chunk_[space] = new_chunk_size;
-  return BackReference::Reference(space, completed_chunks_[space].length(),
-                                  offset);
+  return SerializerReference::BackReference(
+      space, completed_chunks_[space].length(), offset);
 }
 
 void Serializer::Pad() {
   // The non-branching GetInt will read up to 3 bytes too far, so we need
   // to pad the snapshot to make sure we don't read over the end.
   for (unsigned i = 0; i < sizeof(int32_t) - 1; i++) {
     sink_->Put(kNop, "Padding");
   }
   // Pad up to pointer size for checksum.
   while (!IsAligned(sink_->Position(), kPointerAlignment)) {
@@ skipping 22 matching lines @@
 
 void Serializer::ObjectSerializer::SerializePrologue(AllocationSpace space,
                                                      int size, Map* map) {
   if (serializer_->code_address_map_) {
     const char* code_name =
         serializer_->code_address_map_->Lookup(object_->address());
     LOG(serializer_->isolate_,
         CodeNameEvent(object_->address(), sink_->Position(), code_name));
   }
 
-  BackReference back_reference;
+  SerializerReference back_reference;
   if (space == LO_SPACE) {
     sink_->Put(kNewObject + reference_representation_ + space,
                "NewLargeObject");
     sink_->PutInt(size >> kObjectAlignmentBits, "ObjectSizeInWords");
     if (object_->IsCode()) {
       sink_->Put(EXECUTABLE, "executable large object");
     } else {
       sink_->Put(NOT_EXECUTABLE, "not executable large object");
     }
     back_reference = serializer_->AllocateLargeObject(size);
   } else {
     int fill = serializer_->PutAlignmentPrefix(object_);
     back_reference = serializer_->Allocate(space, size + fill);
     sink_->Put(kNewObject + reference_representation_ + space, "NewObject");
     sink_->PutInt(size >> kObjectAlignmentBits, "ObjectSizeInWords");
   }
 
 #ifdef OBJECT_PRINT
   if (FLAG_serialization_statistics) {
     serializer_->CountInstanceType(map, size);
   }
 #endif  // OBJECT_PRINT
 
   // Mark this object as already serialized.
-  serializer_->back_reference_map()->Add(object_, back_reference);
+  serializer_->reference_map()->Add(object_, back_reference);
 
   // Serialize the map (first word of the object).
   serializer_->SerializeObject(map, kPlain, kStartOfObject, 0);
 }
 
 void Serializer::ObjectSerializer::SerializeExternalString() {
   // Instead of serializing this as an external string, we serialize
   // an imaginary sequential string with the same content.
   Isolate* isolate = serializer_->isolate();
   DCHECK(object_->IsExternalString());
@@ skipping 147 matching lines @@
 
 void Serializer::ObjectSerializer::SerializeDeferred() {
   if (FLAG_trace_serializer) {
     PrintF(" Encoding deferred heap object: ");
     object_->ShortPrint();
     PrintF("\n");
   }
 
   int size = object_->Size();
   Map* map = object_->map();
-  BackReference reference = serializer_->back_reference_map()->Lookup(object_);
+  SerializerReference back_reference =
+      serializer_->reference_map()->Lookup(object_);
+  DCHECK(back_reference.is_back_reference());
 
   // Serialize the rest of the object.
   CHECK_EQ(0, bytes_processed_so_far_);
   bytes_processed_so_far_ = kPointerSize;
 
   serializer_->PutAlignmentPrefix(object_);
-  sink_->Put(kNewObject + reference.space(), "deferred object");
-  serializer_->PutBackReference(object_, reference);
+  sink_->Put(kNewObject + back_reference.space(), "deferred object");
+  serializer_->PutBackReference(object_, back_reference);
   sink_->PutInt(size >> kPointerSizeLog2, "deferred object size");
 
   UnlinkWeakNextScope unlink_weak_next(object_);
 
   object_->IterateBody(map->instance_type(), size, this);
   OutputRawData(object_->address() + size);
 }
 
 void Serializer::ObjectSerializer::VisitPointers(Object** start, Object** end) {
   Object** current = start;
@@ skipping 226 matching lines @@
   if (to_skip != 0 && return_skip == kIgnoringReturn) {
     sink_->Put(kSkip, "Skip");
     sink_->PutInt(to_skip, "SkipDistance");
     to_skip = 0;
   }
   return to_skip;
 }
 
 }  // namespace internal
 }  // namespace v8