[snapshot] encode resource before serializing.

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 392 matching lines @@
 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_);
-    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);
+    ExternalOneByteString* string = ExternalOneByteString::cast(object_);
+    DCHECK(string->is_short());
+    const NativesExternalStringResource* resource =
+        reinterpret_cast<const NativesExternalStringResource*>(
+            string->resource());
+    // Replace the resource field with the type and index of the native source.
+    string->set_resource(resource->EncodeForSerialization());
+    SerializeContent();
+    // Restore the resource field.
+    string->set_resource(resource);
   }
 }
 
-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::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;
@@ skipping 83 matching lines @@
 
 void Serializer::ObjectSerializer::Serialize() {
   if (FLAG_trace_serializer) {
     PrintF(" Encoding heap object: ");
     object_->ShortPrint();
     PrintF("\n");
   }
 
   if (object_->IsExternalString()) {
     SerializeExternalString();
-  } else {
-    // We cannot serialize typed array objects correctly.
-    DCHECK(!object_->IsJSTypedArray());
+    return;
+  }
 
-    // We don't expect fillers.
-    DCHECK(!object_->IsFiller());
+  // We cannot serialize typed array objects correctly.
+  DCHECK(!object_->IsJSTypedArray());
 
-    if (object_->IsScript()) {
-      // Clear cached line ends.
-      Object* undefined = serializer_->isolate()->heap()->undefined_value();
-      Script::cast(object_)->set_line_ends(undefined);
-    }
+  // We don't expect fillers.
+  DCHECK(!object_->IsFiller());
 
-    int size = object_->Size();
-    Map* map = object_->map();
-    AllocationSpace space =
-        MemoryChunk::FromAddress(object_->address())->owner()->identity();
-    SerializePrologue(space, size, map);
+  if (object_->IsScript()) {
+    // Clear cached line ends.
+    Object* undefined = serializer_->isolate()->heap()->undefined_value();
+    Script::cast(object_)->set_line_ends(undefined);
+  }
 
-    // Serialize the rest of the object.
-    CHECK_EQ(0, bytes_processed_so_far_);
-    bytes_processed_so_far_ = kPointerSize;
+  SerializeContent();
+}
 
-    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;
-    }
+void Serializer::ObjectSerializer::SerializeContent() {
+  int size = object_->Size();
+  Map* map = object_->map();
+  AllocationSpace space =
+      MemoryChunk::FromAddress(object_->address())->owner()->identity();
+  SerializePrologue(space, size, map);
 
-    UnlinkWeakNextScope unlink_weak_next(object_);
+  // 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);
+  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 217 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