Patch for allowing several V8 instances in process:...

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 73 matching lines @@
     cache_->set(length + 1, *fun);
     Script::cast(fun->shared()->script())->set_type(Smi::FromInt(type_));
   }
 
  private:
   Script::Type type_;
   FixedArray* cache_;
   DISALLOW_COPY_AND_ASSIGN(SourceCodeCache);
 };
 
-static SourceCodeCache natives_cache(Script::TYPE_NATIVE);
-static SourceCodeCache extensions_cache(Script::TYPE_EXTENSION);
-// This is for delete, not delete[].
-static List<char*>* delete_these_non_arrays_on_tear_down = NULL;
+class Genesis;
 
+class BootstrapperPrivateData {
+ public:
+  SourceCodeCache natives_cache_;
+  SourceCodeCache extensions_cache_;
+  Genesis* current_;
+  // This is for delete, not delete[].
+  List<char*>* delete_these_non_arrays_on_tear_down_;
+
+  List<Object*> code_;
+  List<const char*> name_;
+  List<int> pc_;
+  List<uint32_t> flags_;
+
+  BootstrapperPrivateData()
+    :delete_these_non_arrays_on_tear_down_(NULL),
+    current_(NULL),
+    extensions_cache_(Script::TYPE_EXTENSION),
+    natives_cache_(Script::TYPE_NATIVE),
+    code_(0),
+    name_(0),
+    pc_(0),
+    flags_(0) {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(BootstrapperPrivateData);
+};
+
+BootstrapperData::BootstrapperData()
+  :private_data_(*new BootstrapperPrivateData()) {
+}
+
+BootstrapperData::~BootstrapperData() {
+  delete &private_data_;
+}
 
 NativesExternalStringResource::NativesExternalStringResource(const char* source)
     : data_(source), length_(StrLength(source)) {
-  if (delete_these_non_arrays_on_tear_down == NULL) {
-    delete_these_non_arrays_on_tear_down = new List<char*>(2);
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
+  if (data.delete_these_non_arrays_on_tear_down_ == NULL) {
+    data.delete_these_non_arrays_on_tear_down_ = new List<char*>(2);
   }
   // The resources are small objects and we only make a fixed number of
   // them, but let's clean them up on exit for neatness.
-  delete_these_non_arrays_on_tear_down->
+  data.delete_these_non_arrays_on_tear_down_->
       Add(reinterpret_cast<char*>(this));
 }
 
 
 Handle<String> Bootstrapper::NativesSourceLookup(int index) {
   ASSERT(0 <= index && index < Natives::GetBuiltinsCount());
   if (Heap::natives_source_cache()->get(index)->IsUndefined()) {
     if (!Snapshot::IsEnabled() || FLAG_new_snapshot) {
       // We can use external strings for the natives.
       NativesExternalStringResource* resource =
           new NativesExternalStringResource(
               Natives::GetScriptSource(index).start());
       Handle<String> source_code =
           Factory::NewExternalStringFromAscii(resource);
       Heap::natives_source_cache()->set(index, *source_code);
     } else {
       // Old snapshot code can't cope with external strings at all.
       Handle<String> source_code =
         Factory::NewStringFromAscii(Natives::GetScriptSource(index));
       Heap::natives_source_cache()->set(index, *source_code);
     }
   }
   Handle<Object> cached_source(Heap::natives_source_cache()->get(index));
   return Handle<String>::cast(cached_source);
 }
 
 
 bool Bootstrapper::NativesCacheLookup(Vector<const char> name,
                                       Handle<JSFunction>* handle) {
-  return natives_cache.Lookup(name, handle);
+  return v8_context()->bootstrapper_data_.
+    private_data_.natives_cache_.Lookup(name, handle);
 }
 
 
 void Bootstrapper::NativesCacheAdd(Vector<const char> name,
                                    Handle<JSFunction> fun) {
-  natives_cache.Add(name, fun);
+  v8_context()->bootstrapper_data_.
+    private_data_.natives_cache_.Add(name, fun);
 }
 
 
 void Bootstrapper::Initialize(bool create_heap_objects) {
-  natives_cache.Initialize(create_heap_objects);
-  extensions_cache.Initialize(create_heap_objects);
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
+  data.natives_cache_.Initialize(create_heap_objects);
+  data.extensions_cache_.Initialize(create_heap_objects);
 }
 
 
 void Bootstrapper::TearDown() {
-  if (delete_these_non_arrays_on_tear_down != NULL) {
-    int len = delete_these_non_arrays_on_tear_down->length();
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
+  if (data.delete_these_non_arrays_on_tear_down_ != NULL) {
+    int len = data.delete_these_non_arrays_on_tear_down_->length();
     ASSERT(len < 20);  // Don't use this mechanism for unbounded allocations.
     for (int i = 0; i < len; i++) {
-      delete delete_these_non_arrays_on_tear_down->at(i);
+      delete data.delete_these_non_arrays_on_tear_down_->at(i);
     }
-    delete delete_these_non_arrays_on_tear_down;
-    delete_these_non_arrays_on_tear_down = NULL;
+    delete data.delete_these_non_arrays_on_tear_down_;
+    data.delete_these_non_arrays_on_tear_down_ = NULL;
   }
 
-  natives_cache.Initialize(false);  // Yes, symmetrical
-  extensions_cache.Initialize(false);
+  data.natives_cache_.Initialize(false);  // Yes, symmetrical
+  data.extensions_cache_.Initialize(false);
 }
 
 
 // Pending fixups are code positions that refer to builtin code
 // objects that were not available at the time the code was generated.
 // The pending list is processed whenever an environment has been
 // created.
 class PendingFixups : public AllStatic {
  public:
   static void Add(Code* code, MacroAssembler* masm);
   static bool Process(Handle<JSBuiltinsObject> builtins);
 
   static void Iterate(ObjectVisitor* v);
 
  private:
-  static List<Object*> code_;
-  static List<const char*> name_;
-  static List<int> pc_;
-  static List<uint32_t> flags_;
-
   static void Clear();
 };
 
-
-List<Object*> PendingFixups::code_(0);
-List<const char*> PendingFixups::name_(0);
-List<int> PendingFixups::pc_(0);
-List<uint32_t> PendingFixups::flags_(0);
-
-
 void PendingFixups::Add(Code* code, MacroAssembler* masm) {
   // Note this code is not only called during bootstrapping.
   List<MacroAssembler::Unresolved>* unresolved = masm->unresolved();
   int n = unresolved->length();
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
   for (int i = 0; i < n; i++) {
     const char* name = unresolved->at(i).name;
-    code_.Add(code);
-    name_.Add(name);
-    pc_.Add(unresolved->at(i).pc);
-    flags_.Add(unresolved->at(i).flags);
+    data.code_.Add(code);
+    data.name_.Add(name);
+    data.pc_.Add(unresolved->at(i).pc);
+    data.flags_.Add(unresolved->at(i).flags);
     LOG(StringEvent("unresolved", name));
   }
 }
 
 
 bool PendingFixups::Process(Handle<JSBuiltinsObject> builtins) {
   HandleScope scope;
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
   // NOTE: Extra fixups may be added to the list during the iteration
   // due to lazy compilation of functions during the processing. Do not
   // cache the result of getting the length of the code list.
-  for (int i = 0; i < code_.length(); i++) {
-    const char* name = name_[i];
-    uint32_t flags = flags_[i];
+  for (int i = 0; i < data.code_.length(); i++) {
+    const char* name = data.name_[i];
+    uint32_t flags = data.flags_[i];
     Handle<String> symbol = Factory::LookupAsciiSymbol(name);
     Object* o = builtins->GetProperty(*symbol);
 #ifdef DEBUG
     if (!o->IsJSFunction()) {
       V8_Fatal(__FILE__, __LINE__, "Cannot resolve call to builtin %s", name);
     }
 #endif
     Handle<JSFunction> f = Handle<JSFunction>(JSFunction::cast(o));
     // Make sure the number of parameters match the formal parameter count.
     int argc = Bootstrapper::FixupFlagsArgumentsCount::decode(flags);
     USE(argc);
     ASSERT(f->shared()->formal_parameter_count() == argc);
     if (!f->is_compiled()) {
       // Do lazy compilation and check for stack overflows.
       if (!CompileLazy(f, CLEAR_EXCEPTION)) {
         Clear();
         return false;
       }
     }
-    Code* code = Code::cast(code_[i]);
-    Address pc = code->instruction_start() + pc_[i];
+    Code* code = Code::cast(data.code_[i]);
+    Address pc = code->instruction_start() + data.pc_[i];
     RelocInfo target(pc, RelocInfo::CODE_TARGET, 0);
     bool use_code_object = Bootstrapper::FixupFlagsUseCodeObject::decode(flags);
     if (use_code_object) {
       target.set_target_object(f->code());
     } else {
       target.set_target_address(f->code()->instruction_start());
     }
     LOG(StringEvent("resolved", name));
   }
   Clear();
 
   // TODO(1240818): We should probably try to avoid doing this for all
   // the V8 builtin JS files. It should only happen after running
   // runtime.js - just like there shouldn't be any fixups left after
   // that.
   for (int i = 0; i < Builtins::NumberOfJavaScriptBuiltins(); i++) {
     Builtins::JavaScript id = static_cast<Builtins::JavaScript>(i);
     Handle<String> name = Factory::LookupAsciiSymbol(Builtins::GetName(id));
     JSFunction* function = JSFunction::cast(builtins->GetProperty(*name));
     builtins->set_javascript_builtin(id, function);
   }
 
   return true;
 }
 
 
 void PendingFixups::Clear() {
-  code_.Clear();
-  name_.Clear();
-  pc_.Clear();
-  flags_.Clear();
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
+  data.code_.Clear();
+  data.name_.Clear();
+  data.pc_.Clear();
+  data.flags_.Clear();
 }
 
 
 void PendingFixups::Iterate(ObjectVisitor* v) {
-  if (!code_.is_empty()) {
-    v->VisitPointers(&code_[0], &code_[0] + code_.length());
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
+  if (!data.code_.is_empty()) {
+    v->VisitPointers(&data.code_[0], &data.code_[0] + data.code_.length());
   }
 }
 
 
 class Genesis BASE_EMBEDDED {
  public:
   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_; }
+  static Genesis* current() {
+    return v8_context()->bootstrapper_data_.private_data_.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_; }
 
   void CreateRoots(v8::Handle<v8::ObjectTemplate> global_template,
                    Handle<Object> global_object);
   void InstallNativeFunctions();
   bool InstallNatives();
   bool InstallExtensions(v8::ExtensionConfiguration* extensions);
   bool InstallExtension(const char* name);
   bool InstallExtension(v8::RegisteredExtension* current);
@@ skipping 24 matching lines @@
   static bool CompileNative(Vector<const char> name, Handle<String> source);
   static bool CompileScriptCached(Vector<const char> name,
                                   Handle<String> source,
                                   SourceCodeCache* cache,
                                   v8::Extension* extension,
                                   bool use_runtime_context);
 
   Handle<Context> result_;
 };
 
-Genesis* Genesis::current_ = NULL;
 
 
 void Bootstrapper::Iterate(ObjectVisitor* v) {
-  natives_cache.Iterate(v);
+  BootstrapperPrivateData& data = v8_context()->bootstrapper_data_.
+    private_data_;
+  data.natives_cache_.Iterate(v);
   v->Synchronize("NativesCache");
-  extensions_cache.Iterate(v);
+  data.extensions_cache_.Iterate(v);
   v->Synchronize("Extensions");
   PendingFixups::Iterate(v);
   v->Synchronize("PendingFixups");
 }
 
 
 // While setting up the environment, we collect code positions that
 // need to be patched before we can run any code in the environment.
 void Bootstrapper::AddFixup(Code* code, MacroAssembler* masm) {
   PendingFixups::Add(code, masm);
@@ skipping 26 matching lines @@
 void Bootstrapper::DetachGlobal(Handle<Context> env) {
   JSGlobalProxy::cast(env->global_proxy())->set_context(*Factory::null_value());
   SetObjectPrototype(Handle<JSObject>(env->global_proxy()),
                      Factory::null_value());
   env->set_global_proxy(env->global());
   env->global()->set_global_receiver(env->global());
 }
 
 
 Genesis::~Genesis() {
-  ASSERT(current_ == this);
-  current_ = previous_;
+  Genesis* & current = v8_context()->bootstrapper_data_.private_data_.current_;
+  ASSERT(current == this);
+  current = previous_;
 }
 
 
 static Handle<JSFunction> InstallFunction(Handle<JSObject> target,
                                           const char* name,
                                           InstanceType type,
                                           int instance_size,
                                           Handle<JSObject> prototype,
                                           Builtins::Name call,
                                           bool is_ecma_native) {
@@ skipping 471 matching lines @@
   Handle<String> source_code = Bootstrapper::NativesSourceLookup(index);
   return CompileNative(name, source_code);
 }
 
 
 bool Genesis::CompileNative(Vector<const char> name, Handle<String> source) {
   HandleScope scope;
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger::set_compiling_natives(true);
 #endif
-  bool result =
-      CompileScriptCached(name, source, &natives_cache, NULL, true);
+  bool result = CompileScriptCached(name, source,
+    &v8_context()->bootstrapper_data_.private_data_.natives_cache_, NULL, true);
   ASSERT(Top::has_pending_exception() != result);
   if (!result) Top::clear_pending_exception();
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger::set_compiling_natives(false);
 #endif
   return result;
 }
 
 
 bool Genesis::CompileScriptCached(Vector<const char> name,
@@ skipping 355 matching lines @@
         Factory::LookupAsciiSymbol(FLAG_expose_debug_as);
     SetProperty(js_global, debug_string,
         Handle<Object>(Debug::debug_context()->global_proxy()), DONT_ENUM);
   }
 #endif
 
   return true;
 }
 
 
+static MutexLockAdapter genesis_lock_adapter(OS::CreateMutex());
+
 bool Genesis::InstallExtensions(v8::ExtensionConfiguration* extensions) {
+  V8SharedStateLocker locker(&genesis_lock_adapter);
   // Clear coloring of extension list
   v8::RegisteredExtension* current = v8::RegisteredExtension::first_extension();
   while (current != NULL) {
     current->set_state(v8::UNVISITED);
     current = current->next();
   }
   // Install auto extensions
   current = v8::RegisteredExtension::first_extension();
   while (current != NULL) {
     if (current->extension()->auto_enable())
@@ skipping 48 matching lines @@
   }
   ASSERT(current->state() == v8::UNVISITED);
   current->set_state(v8::VISITED);
   v8::Extension* extension = current->extension();
   // Install the extension's dependencies
   for (int i = 0; i < extension->dependency_count(); i++) {
     if (!InstallExtension(extension->dependencies()[i])) return false;
   }
   Vector<const char> source = CStrVector(extension->source());
   Handle<String> source_code = Factory::NewStringFromAscii(source);
-  bool result = CompileScriptCached(CStrVector(extension->name()),
-                                    source_code,
-                                    &extensions_cache, extension,
-                                    false);
+  bool result = CompileScriptCached(
+    CStrVector(extension->name()),
+    source_code,
+    &v8_context()->bootstrapper_data_.private_data_.extensions_cache_,
+    extension,
+    false);
   ASSERT(Top::has_pending_exception() != result);
   if (!result) {
     Top::clear_pending_exception();
   }
   current->set_state(v8::INSTALLED);
   return result;
 }
 
 
 bool Genesis::ConfigureGlobalObjects(
@@ skipping 212 matching lines @@
                      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 destructor
   // will always do unlinking.
-  previous_ = current_;
-  current_  = this;
+  Genesis* & current = v8_context()->bootstrapper_data_.private_data_.current_;
+  previous_ = current;
+  current  = this;
   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 context;
 
@@ skipping 35 matching lines @@
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(Genesis::current() == NULL);
 }
 
 
 // Reserve space for statics needing saving and restoring.
 int Genesis::ArchiveSpacePerThread() {
-  return sizeof(current_);
+  return sizeof(v8_context()->bootstrapper_data_.private_data_.current_);
 }
 
 
 // Archive statics that are thread local.
 char* Genesis::ArchiveState(char* to) {
-  *reinterpret_cast<Genesis**>(to) = current_;
-  current_ = NULL;
-  return to + sizeof(current_);
+  Genesis* & current = v8_context()->bootstrapper_data_.private_data_.current_;
+  *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_);
+  Genesis* & current = v8_context()->bootstrapper_data_.private_data_.current_;
+  current = *reinterpret_cast<Genesis**>(from);
+  return from + sizeof(current);
 }
 
 } }  // namespace v8::internal