Create a internal, global native context used only for generated code stubs

src/snapshot/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 557 matching lines @@
   {
     DisallowHeapAllocation no_gc;
     isolate_->heap()->IterateSmiRoots(this);
     isolate_->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
     isolate_->heap()->RepairFreeListsAfterDeserialization();
     isolate_->heap()->IterateWeakRoots(this, VISIT_ALL);
     DeserializeDeferredObjects();
   }
 
   isolate_->heap()->set_native_contexts_list(
-      isolate_->heap()->undefined_value());
+      isolate_->heap()->code_stub_context());
 
   // The allocation site list is build during root iteration, but if no sites
   // were encountered then it needs to be initialized to undefined.
   if (isolate_->heap()->allocation_sites_list() == Smi::FromInt(0)) {
     isolate_->heap()->set_allocation_sites_list(
         isolate_->heap()->undefined_value());
   }
 
   // Update data pointers to the external strings containing natives sources.
   for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
     Object* source = isolate_->heap()->natives_source_cache()->get(i);
     if (!source->IsUndefined()) {
       ExternalOneByteString::cast(source)->update_data_cache();
     }
   }
 
+  for (int i = 0; i < CodeStubNatives::GetBuiltinsCount(); i++) {
+    Object* source = isolate_->heap()->code_stub_natives_source_cache()->get(i);
+    if (!source->IsUndefined()) {
+      ExternalOneByteString::cast(source)->update_data_cache();
+    }
+  }
+
   FlushICacheForNewCodeObjects();
 
   // Issue code events for newly deserialized code objects.
   LOG_CODE_EVENT(isolate_, LogCodeObjects());
   LOG_CODE_EVENT(isolate_, LogCompiledFunctions());
 }
 
 
 MaybeHandle<Object> Deserializer::DeserializePartial(
     Isolate* isolate, Handle<JSGlobalProxy> global_proxy,
@@ skipping 295 matching lines @@
     // Assert that the current reserved chunk is still big enough.
     const Heap::Reservation& reservation = reservations_[space_index];
     int chunk_index = current_chunk_[space_index];
     CHECK_LE(high_water_[space_index], reservation[chunk_index].end);
 #endif
     return address;
   }
 }
 
 
+Object** Deserializer::CopyInNativesSource(Vector<const char> source_vector,
+                                           Object** current) {
+  DCHECK(!isolate_->heap()->deserialization_complete());
+  NativesExternalStringResource* resource = new NativesExternalStringResource(
+      source_vector.start(), source_vector.length());
+  Object* resource_obj = reinterpret_cast<Object*>(resource);
+  UnalignedCopy(current++, &resource_obj);
+  return current;
+}
+
+
 bool Deserializer::ReadData(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 &&
        source_space != CODE_SPACE);
   while (current < limit) {
@@ skipping 246 matching lines @@
         current = limit;
         return false;
       }
 
       case kSynchronize:
         // If we get here then that indicates that you have a mismatch between
         // the number of GC roots when serializing and deserializing.
         CHECK(false);
         break;
 
       case kNativesStringResource: {

[Yang, 2015/07/10 08:18:57]

no need for the scoping brackets anymore.

[danno, 2015/07/13 09:43:37]

Done

-        DCHECK(!isolate_->heap()->deserialization_complete());
-        int index = source_.Get();
-        Vector<const char> source_vector = Natives::GetScriptSource(index);
-        NativesExternalStringResource* resource =
-            new NativesExternalStringResource(source_vector.start(),
-                                              source_vector.length());
-        Object* resource_obj = reinterpret_cast<Object*>(resource);
-        UnalignedCopy(current++, &resource_obj);
+        current = CopyInNativesSource(Natives::GetScriptSource(source_.Get()),
+                                      current);
         break;
       }
 
+      case kCodeStubNativesStringResource: {
+        current = CopyInNativesSource(
+            CodeStubNatives::GetScriptSource(source_.Get()), current);
+        break;
+      }
+
       // Deserialize raw data of variable length.
       case kVariableRawData: {
         int size_in_bytes = source_.GetInt();
         byte* raw_data_out = reinterpret_cast<byte*>(current);
         source_.CopyRaw(raw_data_out, size_in_bytes);
         break;
       }
 
       case kVariableRepeat: {
         int repeats = source_.GetInt();
@@ skipping 214 matching lines @@
     }
   }
 }
 
 
 void PartialSerializer::Serialize(Object** o) {
   if ((*o)->IsContext()) {
     Context* context = Context::cast(*o);
     global_object_ = context->global_object();
     back_reference_map()->AddGlobalProxy(context->global_proxy());
+    // The bootstrap already snapshot has a code-stub context, when serializing

[Yang, 2015/07/10 08:18:57]

weird sentence...

[danno, 2015/07/13 09:43:37]

Done

+    // the partial snapshot, it is chained into the weak context list on the
+    // isolate and it's next context pointer may point to the code-stub context.
+    // Clear it before serializing, it will get re-added to the context list
+    // explicitly when it's loaded.
+    if (context->IsNativeContext()) {
+      context->set(Context::NEXT_CONTEXT_LINK,
+                   isolate_->heap()->undefined_value());
+      DCHECK(!context->global_object()->IsUndefined());
+      DCHECK(!context->builtins()->IsUndefined());
+    }
   }
   VisitPointer(o);
   SerializeDeferredObjects();
   SerializeOutdatedContextsAsFixedArray();
   Pad();
 }
 
 
 void PartialSerializer::SerializeOutdatedContextsAsFixedArray() {
   int length = outdated_contexts_.length();
@@ skipping 184 matching lines @@
       PutBackReference(obj, back_reference);
     }
     return true;
   }
   return false;
 }
 
 
 void StartupSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
                                         WhereToPoint where_to_point, int skip) {
-  DCHECK(!obj->IsJSFunction());
+  // Make sure that all functions are derived from the code-stub context
+  DCHECK(!obj->IsJSFunction() ||
+         JSFunction::cast(obj)->GetCreationContext() ==
+             isolate()->heap()->code_stub_context());
 
   int root_index = root_index_map_.Lookup(obj);
   // We can only encode roots as such if it has already been serialized.
   // That applies to root indices below the wave front.
   if (root_index != RootIndexMap::kInvalidRootIndex &&
       root_index < root_index_wave_front_) {
     PutRoot(root_index, obj, how_to_code, where_to_point, skip);
     return;
   }
 
@@ skipping 483 matching lines @@
 
 
 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, const char* begin_string,
+    const char* end_string) {
+  for (int i = 0; i < builtin_count; i++) {
+    Object* source = source_cache->get(i);
+    if (!source->IsUndefined()) {
+      ExternalOneByteString* string = ExternalOneByteString::cast(source);
+      typedef v8::String::ExternalOneByteStringResource Resource;
+      const Resource* resource = string->resource();
+      if (resource == *resource_pointer) {
+        sink_->Put(resource_index, begin_string);
+        sink_->PutSection(i, end_string);
+        bytes_processed_so_far_ += sizeof(resource);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+
 void Serializer::ObjectSerializer::VisitExternalOneByteString(
     v8::String::ExternalOneByteStringResource** resource_pointer) {
   Address references_start = reinterpret_cast<Address>(resource_pointer);
   OutputRawData(references_start);
-  for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
-    Object* source =
-        serializer_->isolate()->heap()->natives_source_cache()->get(i);
-    if (!source->IsUndefined()) {
-      ExternalOneByteString* string = ExternalOneByteString::cast(source);
-      typedef v8::String::ExternalOneByteStringResource Resource;
-      const Resource* resource = string->resource();
-      if (resource == *resource_pointer) {
-        sink_->Put(kNativesStringResource, "NativesStringResource");
-        sink_->PutSection(i, "NativesStringResourceEnd");
-        bytes_processed_so_far_ += sizeof(resource);
-        return;
-      }
-    }
+  if (SerializeExternalNativeSourceString(
+          Natives::GetBuiltinsCount(), resource_pointer,
+          serializer_->isolate()->heap()->natives_source_cache(),
+          kNativesStringResource, "NativesStringResource",

[Yang, 2015/07/10 08:18:57]

Those string arguments are really just for documentation. sink_->Put doesn't
actually use them. (We used to use them for when we add printf debugging to
sink_->Put). So you could just omit them as arguments and use "StringResource"
and "StringResourceEnd" in the method itself.

[danno, 2015/07/13 09:43:37]

Done

+          "NativesStringResourceEnd")) {
+    return;
+  }
+  if (SerializeExternalNativeSourceString(
+          CodeStubNatives::GetBuiltinsCount(), resource_pointer,
+          serializer_->isolate()->heap()->code_stub_natives_source_cache(),
+          kCodeStubNativesStringResource, "CodeStubNativesStringResource",
+          "CodeStubNativesStringResourceEnd")) {
+    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() {
   // To make snapshots reproducible, we make a copy of the code object
   // and wipe all pointers in the copy, which we then serialize.
@@ skipping 591 matching lines @@
   SerializedCodeData* scd = new SerializedCodeData(cached_data);
   SanityCheckResult r = scd->SanityCheck(isolate, source);
   if (r == CHECK_SUCCESS) return scd;
   cached_data->Reject();
   source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(r);
   delete scd;
   return NULL;
 }
 }  // namespace internal
 }  // namespace v8