Experimental: periodic merge of the bleeding_edge branch to the...

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 247 matching lines @@
   Genesis(Handle<Object> global_object,
           v8::Handle<v8::ObjectTemplate> global_template,
           v8::ExtensionConfiguration* extensions);
   ~Genesis();
 
   Handle<Context> result() { return result_; }
 
   Genesis* previous() { return previous_; }
   static Genesis* current() { return current_; }
 
+  // Support for thread preemption.
+  static int ArchiveSpacePerThread();
+  static char* ArchiveState(char* to);
+  static char* RestoreState(char* from);
+
  private:
   Handle<Context> global_context_;
 
   // There may be more than one active genesis object: When GC is
   // triggered during environment creation there may be weak handle
   // processing callbacks which may create new environments.
   Genesis* previous_;
   static Genesis* current_;
 
   Handle<Context> global_context() { return global_context_; }
@@ skipping 798 matching lines @@
                         Factory::NewJSObject(Top::object_function(), TENURED),
                         Builtins::FunctionApply,
                         false);
 
     // Make sure that Function.prototype.call appears to be compiled.
     // The code will never be called, but inline caching for call will
     // only work if it appears to be compiled.
     call->shared()->DontAdaptArguments();
     ASSERT(call->is_compiled());
 
-    // Set the expected paramters for apply to 2; required by builtin.
+    // Set the expected parameters for apply to 2; required by builtin.
     apply->shared()->set_formal_parameter_count(2);
 
     // Set the lengths for the functions to satisfy ECMA-262.
     call->shared()->set_length(1);
     apply->shared()->set_length(2);
   }
 
   // Make sure that the builtins object has fast properties.
   // If the ASSERT below fails, please increase the expected number of
   // properties for the builtins object.
@@ skipping 333 matching lines @@
                      Handle<Code>(Builtins::builtin(Builtins::ArrayPop)));
   AddSpecialFunction(prototype, "push",
                      Handle<Code>(Builtins::builtin(Builtins::ArrayPush)));
 }
 
 
 Genesis::Genesis(Handle<Object> global_object,
                  v8::Handle<v8::ObjectTemplate> global_template,
                  v8::ExtensionConfiguration* extensions) {
   // Link this genesis object into the stacked genesis chain. This
-  // must be done before any early exits because the deconstructor
+  // must be done before any early exits because the destructor
   // will always do unlinking.
   previous_ = current_;
   current_  = this;
   result_ = NULL;
 
   // If V8 hasn't been and cannot be initialized, just return.
   if (!V8::HasBeenSetup() && !V8::Initialize(NULL)) return;
 
   // Before creating the roots we must save the context and restore it
   // on all function exits.
   HandleScope scope;
   SaveContext context;
 
   CreateRoots(global_template, global_object);
   if (!InstallNatives()) return;
 
   MakeFunctionInstancePrototypeWritable();
   BuildSpecialFunctionTable();
 
   if (!ConfigureGlobalObjects(global_template)) return;
 
   if (!InstallExtensions(extensions)) return;
 
   if (!InstallSpecialObjects()) return;
 
   result_ = global_context_;
 }
 
+
+// Support for thread preemption.
+
+// Reserve space for statics needing saving and restoring.
+int Bootstrapper::ArchiveSpacePerThread() {
+  return Genesis::ArchiveSpacePerThread();
+}
+
+
+// Archive statics that are thread local.
+char* Bootstrapper::ArchiveState(char* to) {
+  return Genesis::ArchiveState(to);
+}
+
+
+// Restore statics that are thread local.
+char* Bootstrapper::RestoreState(char* from) {
+  return Genesis::RestoreState(from);
+}
+
+
+// Reserve space for statics needing saving and restoring.
+int Genesis::ArchiveSpacePerThread() {
+  return sizeof(current_);
+}
+
+
+// Archive statics that are thread local.
+char* Genesis::ArchiveState(char* to) {
+  *reinterpret_cast<Genesis**>(to) = current_;
+  current_ = NULL;
+  return to + sizeof(current_);
+}
+
+
+// Restore statics that are thread local.
+char* Genesis::RestoreState(char* from) {
+  current_ = *reinterpret_cast<Genesis**>(from);
+  return from + sizeof(current_);
+}
+
 } }  // namespace v8::internal