Handle ExternalStrings directly in the serializer without ObjectVisitor.

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/assembler-inl.h"
 #include "src/deoptimizer.h"
 #include "src/heap/heap-inl.h"
 #include "src/macro-assembler.h"
@@ skipping 383 matching lines @@
 #endif  // OBJECT_PRINT
 
   // Mark this object as already serialized.
   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() {
+  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.
+    SerializeExternalStringAsSequentialString();
+  } else {
+    DCHECK(object_->IsExternalOneByteString());
+    DCHECK(ExternalOneByteString::cast(object_)->is_short());
+    int size = object_->Size();
+    Map* map = object_->map();
+    AllocationSpace space =
+        MemoryChunk::FromAddress(object_->address())->owner()->identity();
+    SerializePrologue(space, size, map);
+    // Serialize the rest of the object.
+    CHECK_EQ(0, bytes_processed_so_far_);

[ulan, 2017/04/06 17:53:08]

Lines 413-421 are from the Serialize function.

The remaining lines are from the former VisitOneByteExternalString function.

+    bytes_processed_so_far_ = kPointerSize;
+    typedef v8::String::ExternalOneByteStringResource Resource;
+    Resource** resource_pointer = reinterpret_cast<Resource**>(
+        HeapObject::RawField(object_, ExternalString::kResourceOffset));
+
+    Address references_start = reinterpret_cast<Address>(resource_pointer);
+    OutputRawData(references_start);
+    if (!SerializeExternalNativeSourceString(
+            Natives::GetBuiltinsCount(), resource_pointer,
+            Natives::GetSourceCache(heap), kNativesStringResource)) {
+      bool result = SerializeExternalNativeSourceString(
+          ExtraNatives::GetBuiltinsCount(), resource_pointer,
+          ExtraNatives::GetSourceCache(heap), kExtraNativesStringResource);
+      // One of the strings in the natives cache should match the resource.  We
+      // don't expect any other kinds of external strings here.
+      USE(result);
+      DCHECK(result);
+    }
+    OutputRawData(object_->address() + size);
+  }
+}
+
+bool Serializer::ObjectSerializer::SerializeExternalNativeSourceString(
+    int builtin_count,
+    v8::String::ExternalOneByteStringResource** resource_pointer,
+    FixedArray* source_cache, int resource_index) {
+  Isolate* isolate = serializer_->isolate();

[ulan, 2017/04/06 17:53:08]

This function moved without any change.

+  for (int i = 0; i < builtin_count; i++) {
+    Object* source = source_cache->get(i);
+    if (!source->IsUndefined(isolate)) {
+      ExternalOneByteString* string = ExternalOneByteString::cast(source);
+      typedef v8::String::ExternalOneByteStringResource Resource;
+      const Resource* resource = string->resource();
+      if (resource == *resource_pointer) {
+        sink_->Put(resource_index, "NativesStringResource");
+        sink_->PutSection(i, "NativesStringResourceEnd");
+        bytes_processed_so_far_ += sizeof(resource);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void Serializer::ObjectSerializer::SerializeExternalStringAsSequentialString() {
   // 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());
   DCHECK(object_->map() != isolate->heap()->native_source_string_map());
   ExternalString* string = ExternalString::cast(object_);
   int length = string->length();
   Map* map;
   int content_size;
   int allocation_size;
@@ skipping 80 matching lines @@
   DisallowHeapAllocation no_gc_;
 };
 
 void Serializer::ObjectSerializer::Serialize() {
   if (FLAG_trace_serializer) {
     PrintF(" Encoding heap object: ");
     object_->ShortPrint();
     PrintF("\n");
   }
 
-  // We cannot serialize typed array objects correctly.
-  DCHECK(!object_->IsJSTypedArray());
+  if (object_->IsExternalString()) {
+    SerializeExternalString();
+  } else {
+    // We cannot serialize typed array objects correctly.
+    DCHECK(!object_->IsJSTypedArray());
 
-  // We don't expect fillers.
-  DCHECK(!object_->IsFiller());
+    // We don't expect fillers.
+    DCHECK(!object_->IsFiller());
 
-  if (object_->IsScript()) {
-    // Clear cached line ends.
-    Object* undefined = serializer_->isolate()->heap()->undefined_value();
-    Script::cast(object_)->set_line_ends(undefined);
-  }
+    if (object_->IsScript()) {
+      // Clear cached line ends.
+      Object* undefined = serializer_->isolate()->heap()->undefined_value();
+      Script::cast(object_)->set_line_ends(undefined);
+    }
 
-  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();
+    int size = object_->Size();

[ulan, 2017/04/06 17:53:08]

This code just moved verbatim from 529.

+    Map* map = object_->map();
+    AllocationSpace space =
+        MemoryChunk::FromAddress(object_->address())->owner()->identity();
+    SerializePrologue(space, size, map);
+
+    // Serialize the rest of the object.
+    CHECK_EQ(0, bytes_processed_so_far_);
+    bytes_processed_so_far_ = kPointerSize;
+
+    RecursionScope recursion(serializer_);
+    // Objects that are immediately post processed during deserialization
+    // cannot be deferred, since post processing requires the object content.
+    if (recursion.ExceedsMaximum() && CanBeDeferred(object_)) {
+      serializer_->QueueDeferredObject(object_);
+      sink_->Put(kDeferred, "Deferring object content");
       return;
     }
+
+    UnlinkWeakNextScope unlink_weak_next(object_);
+
+    object_->IterateBody(map->instance_type(), size, this);
+    OutputRawData(object_->address() + size);
   }
-
-  int size = object_->Size();
-  Map* map = object_->map();
-  AllocationSpace space =
-      MemoryChunk::FromAddress(object_->address())->owner()->identity();
-  SerializePrologue(space, size, map);
-
-  // Serialize the rest of the object.
-  CHECK_EQ(0, bytes_processed_so_far_);
-  bytes_processed_so_far_ = kPointerSize;
-
-  RecursionScope recursion(serializer_);
-  // Objects that are immediately post processed during deserialization
-  // cannot be deferred, since post processing requires the object content.
-  if (recursion.ExceedsMaximum() && CanBeDeferred(object_)) {
-    serializer_->QueueDeferredObject(object_);
-    sink_->Put(kDeferred, "Deferring object content");
-    return;
-  }
-
-  UnlinkWeakNextScope unlink_weak_next(object_);
-
-  object_->IterateBody(map->instance_type(), size, this);
-  OutputRawData(object_->address() + size);
 }
 
 void Serializer::ObjectSerializer::SerializeDeferred() {
   if (FLAG_trace_serializer) {
     PrintF(" Encoding deferred heap object: ");
     object_->ShortPrint();
     PrintF("\n");
   }
 
   int size = object_->Size();
@@ skipping 145 matching lines @@
   bytes_processed_so_far_ += kPointerSize;
 }
 
 void Serializer::ObjectSerializer::VisitCell(RelocInfo* rinfo) {
   int skip = OutputRawData(rinfo->pc(), kCanReturnSkipInsteadOfSkipping);
   Cell* object = Cell::cast(rinfo->target_cell());
   serializer_->SerializeObject(object, kPlain, kInnerPointer, skip);
   bytes_processed_so_far_ += kPointerSize;
 }
 
-bool Serializer::ObjectSerializer::SerializeExternalNativeSourceString(
-    int builtin_count,
-    v8::String::ExternalOneByteStringResource** resource_pointer,
-    FixedArray* source_cache, int resource_index) {
-  Isolate* isolate = serializer_->isolate();
-  for (int i = 0; i < builtin_count; i++) {
-    Object* source = source_cache->get(i);
-    if (!source->IsUndefined(isolate)) {
-      ExternalOneByteString* string = ExternalOneByteString::cast(source);
-      typedef v8::String::ExternalOneByteStringResource Resource;
-      const Resource* resource = string->resource();
-      if (resource == *resource_pointer) {
-        sink_->Put(resource_index, "NativesStringResource");
-        sink_->PutSection(i, "NativesStringResourceEnd");
-        bytes_processed_so_far_ += sizeof(resource);
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-void Serializer::ObjectSerializer::VisitExternalOneByteString(
-    v8::String::ExternalOneByteStringResource** resource_pointer) {
-  DCHECK_EQ(serializer_->isolate()->heap()->native_source_string_map(),
-            object_->map());
-  DCHECK(ExternalOneByteString::cast(object_)->is_short());
-  Address references_start = reinterpret_cast<Address>(resource_pointer);
-  OutputRawData(references_start);
-  if (SerializeExternalNativeSourceString(
-          Natives::GetBuiltinsCount(), resource_pointer,
-          Natives::GetSourceCache(serializer_->isolate()->heap()),
-          kNativesStringResource)) {
-    return;
-  }
-  if (SerializeExternalNativeSourceString(
-          ExtraNatives::GetBuiltinsCount(), resource_pointer,
-          ExtraNatives::GetSourceCache(serializer_->isolate()->heap()),
-          kExtraNativesStringResource)) {
-    return;
-  }
-  // One of the strings in the natives cache should match the resource.  We
-  // don't expect any other kinds of external strings here.
-  UNREACHABLE();
-}
-
 Address Serializer::ObjectSerializer::PrepareCode() {
   Code* code = Code::cast(object_);
   if (FLAG_predictable) {
     // To make snapshots reproducible, we make a copy of the code object
     // and wipe all pointers in the copy, which we then serialize.
     code = serializer_->CopyCode(code);
     int mode_mask = RelocInfo::kCodeTargetMask |
                     RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
                     RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
                     RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) |
@@ skipping 52 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