Serialize all external strings except for native source code strings.

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 1534 matching lines @@
   }
 
   // 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.
-  DCHECK(object_->IsExternalString() && object_->IsInternalizedString());
   Isolate* isolate = serializer_->isolate();
+  DCHECK(object_->IsExternalString());
+  DCHECK(object_->map() != isolate->heap()->native_source_string_map());
   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();
@@ skipping 26 matching lines @@
   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);
+  if (object_->IsExternalString()) {
+    Heap* heap = serializer_->isolate()->heap();
+    if (object_->map() != heap->native_source_string_map()) {
+      // Usually we cannot recreate resources for external strings. To work
+      // around this, external strings are serialized to look like ordinary
+      // sequential strings.
+      // The exception are native source code strings, since we can recreate
+      // their resources. In that case we fall through and leave it to
+      // VisitExternalOneByteString further down.
+      SerializeExternalString();
+      return;
+    }
+  }
 
-    // Serialize the rest of the object.
-    CHECK_EQ(0, bytes_processed_so_far_);
-    bytes_processed_so_far_ = kPointerSize;
+  int size = object_->Size();
+  Map* map = object_->map();
+  SerializePrologue(Serializer::SpaceOfObject(object_), size, map);
 
-    object_->IterateBody(map->instance_type(), size, this);
-    OutputRawData(object_->address() + size);
-  }
+  // 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));
 
@@ skipping 548 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