Serialize external strings in the code serializer.

src/serialize.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 816 matching lines @@
     deserialized_large_objects_.Add(obj);
     return obj->address();
   } else {
     DCHECK(space_index < kNumberOfPreallocatedSpaces);
     Address address = high_water_[space_index];
     high_water_[space_index] = address + size;
     return address;
   }
 }
 
+
 void Deserializer::ReadChunk(Object** current,
                              Object** limit,
                              int source_space,
                              Address current_object_address) {
   Isolate* const isolate = isolate_;
   // Write barrier support costs around 1% in startup time.  In fact there
   // are no new space objects in current boot snapshots, so it's not needed,
   // but that may change.
   bool write_barrier_needed = (current_object_address != NULL &&
                                source_space != NEW_SPACE &&
@@ skipping 660 matching lines @@
     ObjectSerializer serializer(this,
                                 heap_object,
                                 sink_,
                                 how_to_code,
                                 where_to_point);
     serializer.Serialize();
   }
 }
 
 
-void Serializer::ObjectSerializer::Serialize() {
-  int space = Serializer::SpaceOfObject(object_);
-  int size = object_->Size();
-
+void Serializer::ObjectSerializer::SerializePrologue(int space, int size,
+                                                     Map* map) {
   sink_->Put(kNewObject + reference_representation_ + space,
              "ObjectSerialization");
   sink_->PutInt(size >> kObjectAlignmentBits, "Size in words");
 
   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));
     LOG(serializer_->isolate_,
         SnapshotPositionEvent(object_->address(), sink_->Position()));
   }
 
   // Mark this object as already serialized.
   if (space == LO_SPACE) {
     if (object_->IsCode()) {
       sink_->PutInt(EXECUTABLE, "executable large object");
     } else {
       sink_->PutInt(NOT_EXECUTABLE, "not executable large object");
     }
     int index = serializer_->AllocateLargeObject(size);
     serializer_->address_mapper()->AddMapping(object_, index);
   } else {
     int offset = serializer_->Allocate(space, size);
     serializer_->address_mapper()->AddMapping(object_, offset);
   }
 
   // Serialize the map (first word of the object).
-  serializer_->SerializeObject(object_->map(), kPlain, kStartOfObject, 0);
-
-  // Serialize the rest of the object.
-  CHECK_EQ(0, bytes_processed_so_far_);
-  bytes_processed_so_far_ = kPointerSize;
-  object_->IterateBody(object_->map()->instance_type(), size, this);
-  OutputRawData(object_->address() + size);
+  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.
+  DCHECK(object_->IsExternalString() && object_->IsInternalizedString());
+  Isolate* isolate = serializer_->isolate();
+  ExternalString* string = ExternalString::cast(object_);
+  int length = string->length();
+  Map* map;
+  int size;
+  const char* resource;
+  // Find the map and size for the imaginary sequential string.
+  if (object_->IsExternalOneByteString()) {
+    map = isolate->heap()->one_byte_internalized_string_map();
+    size = SeqOneByteString::SizeFor(length);
+    resource = ExternalOneByteString::cast(string)->resource()->data();
+  } else {
+    map = isolate->heap()->internalized_string_map();
+    size = SeqTwoByteString::SizeFor(length);
+    resource = reinterpret_cast<const char*>(
+        ExternalTwoByteString::cast(string)->resource()->data());
+  }
+
+  int space =
+      (size > Page::kMaxRegularHeapObjectSize) ? LO_SPACE : OLD_DATA_SPACE;
+  SerializePrologue(space, size, map);
+
+  // Output the rest of the imaginary string.
+  int bytes_to_output = size - HeapObject::kHeaderSize;
+
+  // Output raw data header. Do not bother with common raw length cases here.
+  sink_->Put(kRawData, "RawDataForString");
+  sink_->PutInt(bytes_to_output, "length");
+
+  // Serialize string header (except for map).
+  Address string_start = string->address();
+  for (int i = HeapObject::kHeaderSize; i < SeqString::kHeaderSize; i++) {
+    sink_->PutSection(string_start[i], "StringHeader");
+  }
+
+  // Serialize string content.
+  int content_length = size - SeqString::kHeaderSize;
+  for (int i = 0; i < content_length; i++) {
+    sink_->PutSection(resource[i], "StringContent");
+  }
+
+  sink_->Put(kSkip, "SkipAfterString");
+  sink_->PutInt(bytes_to_output, "SkipDistance");
+}
+
+
+void Serializer::ObjectSerializer::Serialize() {
+  if (object_->IsExternalString() && object_->IsInternalizedString()) {
+    // Native source code strings are not internalized and are handled in
+    // VisitExternalOneByteString.  We deal with embedded external strings
+    // by serializing them as sequential strings on the heap.
+    // This can only happen with CodeSerializer.
+    SerializeExternalString();
+  } else {
+    int size = object_->Size();
+    Map* map = object_->map();
+    SerializePrologue(Serializer::SpaceOfObject(object_), size, map);
+
+    // Serialize the rest of the object.
+    CHECK_EQ(0, bytes_processed_so_far_);
+    bytes_processed_so_far_ = kPointerSize;
+
+    object_->IterateBody(map->instance_type(), size, this);
+    OutputRawData(object_->address() + size);
+  }
+}
+
+
 void Serializer::ObjectSerializer::VisitPointers(Object** start,
                                                  Object** end) {
   Object** current = start;
   while (current < end) {
     while (current < end && (*current)->IsSmi()) current++;
     if (current < end) OutputRawData(reinterpret_cast<Address>(current));
 
     while (current < end && !(*current)->IsSmi()) {
       HeapObject* current_contents = HeapObject::cast(*current);
       int root_index = serializer_->RootIndex(current_contents, kPlain);
@@ skipping 121 matching lines @@
       const Resource* resource = string->resource();
       if (resource == *resource_pointer) {
         sink_->Put(kNativesStringResource, "NativesStringResource");
         sink_->PutSection(i, "NativesStringResourceEnd");
         bytes_processed_so_far_ += sizeof(resource);
         return;
       }
     }
   }
   // One of the strings in the natives cache should match the resource.  We
-  // can't serialize any other kinds of external strings.
+  // don't expect any other kinds of external strings here.
   UNREACHABLE();
 }
 
 
 static Code* CloneCodeObject(HeapObject* code) {
   Address copy = new byte[code->Size()];
   MemCopy(copy, code->address(), code->Size());
   return Code::cast(HeapObject::FromAddress(copy));
 }
 
@@ skipping 158 matching lines @@
                                      WhereToPoint where_to_point, int skip) {
   HeapObject* heap_object = HeapObject::cast(o);
 
   int root_index;
   if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
     PutRoot(root_index, heap_object, how_to_code, where_to_point, skip);
     return;
   }
 
   if (address_mapper_.IsMapped(heap_object)) {
+    if (FLAG_trace_code_serializer) {
+      PrintF("Encoding back reference to: ");
+      heap_object->ShortPrint();
+      PrintF("\n");
+    }
     SerializeReferenceToPreviousObject(heap_object, how_to_code, where_to_point,
                                        skip);
     return;
   }
 
   if (skip != 0) {
     sink_->Put(kSkip, "SkipFromSerializeObject");
     sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
   }
 
@@ skipping 219 matching lines @@
 
 int SerializedCodeData::CheckSum(String* string) {
   int checksum = Version::Hash();
 #ifdef DEBUG
   uint32_t seed = static_cast<uint32_t>(checksum);
   checksum = static_cast<int>(IteratingStringHasher::Hash(string, seed));
 #endif  // DEBUG
   return checksum;
 }
 } }  // namespace v8::internal