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

src/builtins.h

 // 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 134 matching lines @@
   V(TO_NUMBER, 0)                        \
   V(TO_STRING, 0)                        \
   V(STRING_ADD_LEFT, 1)                  \
   V(STRING_ADD_RIGHT, 1)                 \
   V(APPLY_PREPARE, 1)                    \
   V(APPLY_OVERFLOW, 1)
 
 
 class ObjectVisitor;
 
+class BuiltinTypes {
+ public:
+    enum Name {
+  #define DEF_ENUM_C(name) name,
+  #define DEF_ENUM_A(name, kind, state) name,
+      BUILTIN_LIST_C(DEF_ENUM_C)
+      BUILTIN_LIST_A(DEF_ENUM_A)
+      BUILTIN_LIST_DEBUG_A(DEF_ENUM_A)
+  #undef DEF_ENUM_C
+  #undef DEF_ENUM_A
+      builtin_count
+    };
+};
 
-class Builtins : public AllStatic {
+class BuiltinsData: public BuiltinTypes {
+ public:
+  // 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* builtin_passed_function_;
+ private:
+  // Note: These are always Code objects, but to conform with
+  // IterateBuiltins() above which assumes Object**'s for the callback
+  // function f, we use an Object* array here.
+  Object* builtins_[builtin_count];
+  const char* names_[builtin_count];
+  bool is_initialized_;
+
+  friend class V8Context;
+  friend class Builtins;
+
+  BuiltinsData();
+  DISALLOW_COPY_AND_ASSIGN(BuiltinsData);
+};
+
+class Builtins : public AllStatic, public BuiltinTypes {
  public:
   // Generate all builtin code objects. Should be called once during
   // VM initialization.
   static void Setup(bool create_heap_objects);
   static void TearDown();
 
   // Garbage collection support.
   static void IterateBuiltins(ObjectVisitor* v);
 
   // Disassembler support.
   static const char* Lookup(byte* pc);
 
-  enum Name {
-#define DEF_ENUM_C(name) name,
-#define DEF_ENUM_A(name, kind, state) name,
-    BUILTIN_LIST_C(DEF_ENUM_C)
-    BUILTIN_LIST_A(DEF_ENUM_A)
-    BUILTIN_LIST_DEBUG_A(DEF_ENUM_A)
-#undef DEF_ENUM_C
-#undef DEF_ENUM_A
-    builtin_count
-  };
-
   enum CFunctionId {
 #define DEF_ENUM_C(name) c_##name,
     BUILTIN_LIST_C(DEF_ENUM_C)
 #undef DEF_ENUM_C
     cfunction_count
   };
 
   enum JavaScript {
 #define DEF_ENUM(name, ignore) name,
     BUILTINS_LIST_JS(DEF_ENUM)
 #undef DEF_ENUM
     id_count
   };
 
   static Code* builtin(Name name) {
     // Code::cast cannot be used here since we access builtins
     // during the marking phase of mark sweep. See IC::Clear.
-    return reinterpret_cast<Code*>(builtins_[name]);
+    return reinterpret_cast<Code*>(
+      v8_context()->builtins_data_.builtins_[name]);
   }
 
   static Address builtin_address(Name name) {
-    return reinterpret_cast<Address>(&builtins_[name]);
+    return reinterpret_cast<Address>(
+      &v8_context()->builtins_data_.builtins_[name]);
   }
 
   static Address c_function_address(CFunctionId id) {
     return c_functions_[id];
   }
 
   static const char* GetName(JavaScript id) { return javascript_names_[id]; }
   static int GetArgumentsCount(JavaScript id) { return javascript_argc_[id]; }
   static Handle<Code> GetCode(JavaScript id, bool* resolved);
   static int NumberOfJavaScriptBuiltins() { return id_count; }
 
-  static Object* builtin_passed_function;
 
  private:
   // The external C++ functions called from the code.
   static Address c_functions_[cfunction_count];
 
-  // Note: These are always Code objects, but to conform with
-  // IterateBuiltins() above which assumes Object**'s for the callback
-  // function f, we use an Object* array here.
-  static Object* builtins_[builtin_count];
-  static const char* names_[builtin_count];
   static const char* javascript_names_[id_count];
   static int javascript_argc_[id_count];
 
   static void Generate_Adaptor(MacroAssembler* masm, CFunctionId id);
   static void Generate_JSConstructCall(MacroAssembler* masm);
   static void Generate_JSConstructStubGeneric(MacroAssembler* masm);
   static void Generate_JSEntryTrampoline(MacroAssembler* masm);
   static void Generate_JSConstructEntryTrampoline(MacroAssembler* masm);
   static void Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm);
 
   static void Generate_FunctionCall(MacroAssembler* masm);
   static void Generate_FunctionApply(MacroAssembler* masm);
 
   static void Generate_ArrayCode(MacroAssembler* masm);
   static void Generate_ArrayConstructCode(MacroAssembler* masm);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_BUILTINS_H_