Partial snapshots now working for new context creation. Passes V8 tests....

src/bootstrapper.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 326 matching lines @@
   // Used both for deserialized and from-scratch contexts to add the extensions
   // provided.
   static bool InstallExtensions(Handle<Context> global_context,
                                 v8::ExtensionConfiguration* extensions);
   static bool InstallExtension(const char* name);
   static bool InstallExtension(v8::RegisteredExtension* current);
   static void InstallSpecialObjects(Handle<Context> global_context);
   bool ConfigureApiObject(Handle<JSObject> object,
                           Handle<ObjectTemplateInfo> object_template);
   bool ConfigureGlobalObjects(v8::Handle<v8::ObjectTemplate> global_template);
+  void TransferMapsToDeserializedGlobals(
+    Handle<GlobalObject> inner_global_outside_snapshot,
+    Handle<GlobalObject> inner_global_from_snapshot);
 
   // Migrates all properties from the 'from' object to the 'to'
   // object and overrides the prototype in 'to' with the one from
   // 'from'.
   void TransferObject(Handle<JSObject> from, Handle<JSObject> to);
   void TransferNamedProperties(Handle<JSObject> from, Handle<JSObject> to);
   void TransferIndexedProperties(Handle<JSObject> from, Handle<JSObject> to);
 
   Handle<DescriptorArray> ComputeFunctionInstanceDescriptor(
       bool make_prototype_read_only,
@@ skipping 233 matching lines @@
     v8::NeanderArray listeners;
     global_context()->set_message_listeners(*listeners.value());
   }
 }
 
 
 Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
     v8::Handle<v8::ObjectTemplate> global_template,
     Handle<Object> global_object,
     Handle<GlobalObject>* inner_global_out) {
+  // The argument global_template aka data is an ObjectTemplateInfo.
+  // It has a constructor pointer that points at global_constructor which is a
+  // FunctionTemplateInfo.
+  // The global_constructor is used to create or reinitialize the global_proxy.
+  // The global_constructor also has a prototype_template pointer that points at
+  // js_global_template which is an ObjectTemplateInfo.
+  // That in turn has a constructor pointer that points at
+  // js_global_constructor which is a FunctionTemplateInfo.
+  // js_global_constructor is used to make js_global_function
+  // js_global_function is used to make the new inner_global.
+  //
   // --- G l o b a l ---
   // Step 1: Create a fresh inner JSGlobalObject.
   Handle<JSFunction> js_global_function;
   Handle<ObjectTemplateInfo> js_global_template;
   if (!global_template.IsEmpty()) {
     // Get prototype template of the global_template.
     Handle<ObjectTemplateInfo> data =
         v8::Utils::OpenHandle(*global_template);
     Handle<FunctionTemplateInfo> global_constructor =
         Handle<FunctionTemplateInfo>(
@@ skipping 766 matching lines @@
                                     false);
   ASSERT(Top::has_pending_exception() != result);
   if (!result) {
     Top::clear_pending_exception();
   }
   current->set_state(v8::INSTALLED);
   return result;
 }
 
 
+void Genesis::TransferMapsToDeserializedGlobals(

[Mads Ager (chromium), 2010/02/15 08:36:24]

Maps -> Map?
Globals -> Global?

+    Handle<GlobalObject> inner_global_outside_snapshot,
+    Handle<GlobalObject> inner_global_from_snapshot) {
+  Handle<Map> from_map(inner_global_outside_snapshot->map());
+#ifdef DEBUG
+  Handle<Map> to_map(inner_global_from_snapshot->map());
+  ASSERT_EQ(to_map->instance_size(), from_map->instance_size());
+  ASSERT_EQ(0, to_map->inobject_properties());
+  ASSERT_EQ(0, from_map->inobject_properties());
+#endif
+  inner_global_from_snapshot->set_map(*from_map);
+}
+
+
 bool Genesis::ConfigureGlobalObjects(
     v8::Handle<v8::ObjectTemplate> global_proxy_template) {
   Handle<JSObject> global_proxy(
       JSObject::cast(global_context()->global_proxy()));
   Handle<JSObject> js_global(JSObject::cast(global_context()->global()));
 
   if (!global_proxy_template.IsEmpty()) {
     // Configure the global proxy object.
     Handle<ObjectTemplateInfo> proxy_data =
         v8::Utils::OpenHandle(*global_proxy_template);
@@ skipping 56 matching lines @@
               Handle<JSFunction>(descs->GetConstantFunction(i));
           SetProperty(to, key, fun, details.attributes());
           break;
         }
         case CALLBACKS: {
           LookupResult result;
           to->LocalLookup(descs->GetKey(i), &result);
           // If the property is already there we skip it
           if (result.IsValid()) continue;
           HandleScope inner;
-          Handle<DescriptorArray> inst_descs =
-              Handle<DescriptorArray>(to->map()->instance_descriptors());
+          ASSERT(!to->HasFastProperties());
+          // Add to dictionary.
           Handle<String> key = Handle<String>(descs->GetKey(i));
-          Handle<Object> entry = Handle<Object>(descs->GetCallbacksObject(i));
-          inst_descs = Factory::CopyAppendProxyDescriptor(inst_descs,
-                                                          key,
-                                                          entry,
-                                                          details.attributes());
-          to->map()->set_instance_descriptors(*inst_descs);
+          Handle<Object> callbacks(descs->GetCallbacksObject(i));
+          PropertyDetails d =
+              PropertyDetails(details.attributes(), CALLBACKS, details.index());
+          SetNormalizedProperty(to, key, callbacks, d);
           break;
         }
         case MAP_TRANSITION:
         case CONSTANT_TRANSITION:
         case NULL_DESCRIPTOR:
           // Ignore non-properties.
           break;
         case NORMAL:
           // Do not occur since the from object has fast properties.
         case INTERCEPTOR:
@@ skipping 124 matching lines @@
                  v8::ExtensionConfiguration* extensions) {
   result_ = Handle<Context>::null();
   // If V8 isn't running and cannot be initialized, just return.
   if (!V8::IsRunning() && !V8::Initialize(NULL)) return;
 
   // Before creating the roots we must save the context and restore it
   // on all function exits.
   HandleScope scope;
   SaveContext saved_context;
 
-  if (global_template.IsEmpty()) {
-    Handle<Context> new_context = Snapshot::NewContextFromSnapshot();
-    if (!new_context.is_null()) {
-      global_context_ =
-        Handle<Context>::cast(GlobalHandles::Create(*new_context));
-      Top::set_context(*global_context_);
-      i::Counters::contexts_created_by_snapshot.Increment();
-      result_ = global_context_;
-      JSFunction* empty_function =
-          JSFunction::cast(result_->function_map()->prototype());
-      empty_function_ = Handle<JSFunction>(empty_function);
-      Handle<JSGlobalProxy> global_proxy =
-          CreateNewGlobals(global_template, global_object, NULL);
-      // CreateNewGlobals can return an inner global that it just made, but
-      // we will ignore that because we want to hook up the global proxy to
-      // the one from the snapshot.
-      Handle<GlobalObject> inner_global(
-          GlobalObject::cast(global_context_->extension()));
-      HookUpGlobalProxy(inner_global, global_proxy);
-      if (!ConfigureGlobalObjects(global_template)) return;
-    }
-  }
-  if (global_context_.is_null()) {
-    // We get here if there either was no context snapshot or we couldn't use
-    // the context snapshot because we were supplied with a global template.
+  Handle<Context> new_context = Snapshot::NewContextFromSnapshot();
+  if (!new_context.is_null()) {
+    global_context_ =
+      Handle<Context>::cast(GlobalHandles::Create(*new_context));
+    Top::set_context(*global_context_);
+    i::Counters::contexts_created_by_snapshot.Increment();
+    result_ = global_context_;
+    JSFunction* empty_function =
+        JSFunction::cast(result_->function_map()->prototype());
+    empty_function_ = Handle<JSFunction>(empty_function);
+    Handle<GlobalObject> inner_global_outside_snapshot;
+    Handle<JSGlobalProxy> global_proxy =
+        CreateNewGlobals(global_template,
+                         global_object,
+                         &inner_global_outside_snapshot);
+    // CreateNewGlobals returns an inner global that it just made, but
+    // we won't give that to HookUpGlobalProxy because we want to hook
+    // up the global proxy to the one from the snapshot.
+    Handle<GlobalObject> inner_global(
+        GlobalObject::cast(global_context_->extension()));
+    HookUpGlobalProxy(inner_global, global_proxy);
+    TransferMapsToDeserializedGlobals(inner_global_outside_snapshot,
+                                      inner_global);
+    if (!ConfigureGlobalObjects(global_template)) return;
+  } else {
+    // We get here if there was no context snapshot.
     CreateRoots();
     Handle<JSFunction> empty_function = CreateEmptyFunction();
     Handle<GlobalObject> inner_global;
     Handle<JSGlobalProxy> global_proxy =
         CreateNewGlobals(global_template, global_object, &inner_global);
     HookUpGlobalProxy(inner_global, global_proxy);
     InitializeGlobal(inner_global, empty_function);
     if (!InstallNatives()) return;
 
     MakeFunctionInstancePrototypeWritable();
@@ skipping 47 matching lines @@
 }
 
 
 // Restore statics that are thread local.
 char* BootstrapperActive::RestoreState(char* from) {
   nesting_ = *reinterpret_cast<int*>(from);
   return from + sizeof(nesting_);
 }
 
 } }  // namespace v8::internal