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

src/builtins.cc

Index: src/builtins.cc
===================================================================
--- src/builtins.cc	(revision 3427)
+++ src/builtins.cc	(working copy)
@@ -136,7 +136,7 @@
 
 
 BUILTIN(ArrayCodeGeneric) {
-  Counters::array_function_runtime.Increment();
+  INC_COUNTER(array_function_runtime);
 
   JSArray* array;
   if (CalledAsConstructor()) {
@@ -326,7 +326,8 @@
 
   // TODO(428): Remove use of static variable, handle API callbacks directly.
   Handle<JSFunction> function =
-      Handle<JSFunction>(JSFunction::cast(Builtins::builtin_passed_function));
+      Handle<JSFunction>(JSFunction::cast(
+        v8_context()->builtins_data_.builtin_passed_function_));
 
   if (is_construct) {
     Handle<FunctionTemplateInfo> desc =
@@ -482,13 +483,7 @@
 BUILTIN_END
 
 
-// TODO(1238487): This is a nasty hack. We need to improve the way we
-// call builtins considerable to get rid of this and the hairy macros
-// in builtins.cc.
-Object* Builtins::builtin_passed_function;
 
-
-
 static void Generate_LoadIC_ArrayLength(MacroAssembler* masm) {
   LoadIC::GenerateArrayLength(masm);
 }
@@ -700,8 +695,13 @@
 }
 #endif
 
-Object* Builtins::builtins_[builtin_count] = { NULL, };
-const char* Builtins::names_[builtin_count] = { NULL, };
+BuiltinsData::BuiltinsData()
+  :is_initialized_(false), builtin_passed_function_(NULL) {
+  for (int i = 0; i < builtin_count; ++i) {
+    builtins_[i] = NULL;
+    names_[i] = NULL;
+  }
+}
 
 #define DEF_ENUM_C(name) FUNCTION_ADDR(Builtin_##name),
   Address Builtins::c_functions_[cfunction_count] = {
@@ -721,9 +721,9 @@
 #undef DEF_JS_NAME
 #undef DEF_JS_ARGC
 
-static bool is_initialized = false;
 void Builtins::Setup(bool create_heap_objects) {
-  ASSERT(!is_initialized);
+  BuiltinsData& data = v8_context()->builtins_data_;
+  ASSERT(!data.is_initialized_);
 
   // Create a scope for the handles in the builtins.
   HandleScope scope;
@@ -800,7 +800,7 @@
       // Log the event and add the code to the builtins array.
       LOG(CodeCreateEvent(Logger::BUILTIN_TAG,
                           Code::cast(code), functions[i].s_name));
-      builtins_[i] = code;
+      data.builtins_[i] = code;
 #ifdef ENABLE_DISASSEMBLER
       if (FLAG_print_builtin_code) {
         PrintF("Builtin: %s\n", functions[i].s_name);
@@ -810,32 +810,35 @@
 #endif
     } else {
       // Deserializing. The values will be filled in during IterateBuiltins.
-      builtins_[i] = NULL;
+      data.builtins_[i] = NULL;
     }
-    names_[i] = functions[i].s_name;
+    data.names_[i] = functions[i].s_name;
   }
 
   // Mark as initialized.
-  is_initialized = true;
+  data.is_initialized_ = true;
 }
 
 
 void Builtins::TearDown() {
-  is_initialized = false;
+  v8_context()->builtins_data_.is_initialized_ = false;
 }
 
 
 void Builtins::IterateBuiltins(ObjectVisitor* v) {
-  v->VisitPointers(&builtins_[0], &builtins_[0] + builtin_count);
+  BuiltinsData& data = v8_context()->builtins_data_;
+  v->VisitPointers(&data.builtins_[0], &data.builtins_[0] + builtin_count);
 }
 
 
 const char* Builtins::Lookup(byte* pc) {
-  if (is_initialized) {  // may be called during initialization (disassembler!)
+  BuiltinsData& data = v8_context()->builtins_data_;
+  if (data.is_initialized_) {
+    // may be called during initialization (disassembler!)
     for (int i = 0; i < builtin_count; i++) {
-      Code* entry = Code::cast(builtins_[i]);
+      Code* entry = Code::cast(data.builtins_[i]);
       if (entry->contains(pc)) {
-        return names_[i];
+        return data.names_[i];
       }
     }
   }