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

src/api.cc

 // Copyright 2009 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 45 matching lines @@
 
 
 #define ON_BAILOUT(location, code)              \
   if (IsDeadCheck(location)) {                  \
     code;                                       \
     UNREACHABLE();                              \
   }
 
 
 #define EXCEPTION_PREAMBLE()                                      \
-  thread_local.IncrementCallDepth();                              \
+  v8_context()->handle_scope_implementer_.IncrementCallDepth();   \
   ASSERT(!i::Top::external_caught_exception());                   \
   bool has_pending_exception = false
 
 
 #define EXCEPTION_BAILOUT_CHECK(value)                                         \
   do {                                                                         \
+    i::HandleScopeImplementer& thread_local =                                  \
+      v8_context()->handle_scope_implementer_;                                 \
     thread_local.DecrementCallDepth();                                         \
     if (has_pending_exception) {                                               \
       if (thread_local.CallDepthIsZero() && i::Top::is_out_of_memory()) {      \
         if (!thread_local.ignore_out_of_memory())                              \
           i::V8::FatalProcessOutOfMemory(NULL);                                \
       }                                                                        \
       bool call_depth_is_zero = thread_local.CallDepthIsZero();                \
       i::Top::OptionalRescheduleException(call_depth_is_zero);                 \
       return value;                                                            \
     }                                                                          \
   } while (false)
 
 
 #define API_ENTRY_CHECK(msg)                                                   \
   do {                                                                         \
     if (v8::Locker::IsActive()) {                                              \
       ApiCheck(i::ThreadManager::IsLockedByCurrentThread(),                    \
                msg,                                                            \
                "Entering the V8 API without proper locking in place");         \
     }                                                                          \
   } while (false)
 
 // --- D a t a   t h a t   i s   s p e c i f i c   t o   a   t h r e a d ---
 
 
-static i::HandleScopeImplementer thread_local;
 
 
-// --- E x c e p t i o n   B e h a v i o r ---
 
 
-static FatalErrorCallback exception_behavior = NULL;
+
 int i::Internals::kJSObjectType = JS_OBJECT_TYPE;
 int i::Internals::kFirstNonstringType = FIRST_NONSTRING_TYPE;
 int i::Internals::kProxyType = PROXY_TYPE;
 
 static void DefaultFatalErrorHandler(const char* location,
                                      const char* message) {
   ENTER_V8;
   API_Fatal(location, message);
 }
 
 
 
-static FatalErrorCallback& GetFatalErrorHandler() {
-  if (exception_behavior == NULL) {
-    exception_behavior = DefaultFatalErrorHandler;
+static FatalErrorCallback GetFatalErrorHandler() {
+  internal::V8Data& v8_data = v8_context()->v8_data_;
+  if (v8_data.exception_behavior() == NULL) {
+    v8_data.exception_behavior(DefaultFatalErrorHandler);
   }
-  return exception_behavior;
+  return v8_data.exception_behavior();
 }
 
 
 
 // When V8 cannot allocated memory FatalProcessOutOfMemory is called.
 // The default fatal error handler is called and execution is stopped.
 void i::V8::FatalProcessOutOfMemory(const char* location) {
   i::HeapStats heap_stats;
   int start_marker;
   heap_stats.start_marker = &start_marker;
@@ skipping 41 matching lines @@
   {
     LEAVE_V8;
     callback(location, "Allocation failed - process out of memory");
   }
   // If the callback returns, we stop execution.
   UNREACHABLE();
 }
 
 
 void V8::SetFatalErrorHandler(FatalErrorCallback that) {
-  exception_behavior = that;
+  v8_context()->v8_data_.exception_behavior(that);
 }
 
 
 bool Utils::ReportApiFailure(const char* location, const char* message) {
   FatalErrorCallback callback = GetFatalErrorHandler();
   callback(location, message);
   i::V8::SetFatalError();
   return false;
 }
 
@@ skipping 47 matching lines @@
 }
 
 
 static inline bool EmptyCheck(const char* location, const v8::Data* obj) {
   return (obj == 0) ? ReportEmptyHandle(location) : false;
 }
 
 // --- S t a t i c s ---
 
 
-static i::StringInputBuffer write_input_buffer;
 
 
 static inline bool EnsureInitialized(const char* location) {
   if (i::V8::IsRunning()) {
     return true;
   }
   if (IsDeadCheck(location)) {
     return false;
   }
   return ApiCheck(v8::V8::Initialize(), location, "Error initializing V8");
 }
 
 
 ImplementationUtilities::HandleScopeData*
     ImplementationUtilities::CurrentHandleScope() {
-  return &i::HandleScope::current_;
+  return &v8_context()->handle_scope_data_;
 }
 
 
 #ifdef DEBUG
 void ImplementationUtilities::ZapHandleRange(i::Object** begin,
                                              i::Object** end) {
   i::HandleScope::ZapRange(begin, end);
 }
 #endif
 
@@ skipping 41 matching lines @@
     i::Top::ScheduleThrow(i::Heap::undefined_value());
   } else {
     i::Top::ScheduleThrow(*Utils::OpenHandle(*value));
   }
   return v8::Undefined();
 }
 
 
 RegisteredExtension* RegisteredExtension::first_extension_ = NULL;
 
-
 RegisteredExtension::RegisteredExtension(Extension* extension)
     : extension_(extension), state_(UNVISITED) { }
 
 
 void RegisteredExtension::Register(RegisteredExtension* that) {
   that->next_ = RegisteredExtension::first_extension_;
   RegisteredExtension::first_extension_ = that;
 }
 
-
 void RegisterExtension(Extension* that) {
   RegisteredExtension* extension = new RegisteredExtension(that);
   RegisteredExtension::Register(extension);
 }
 
 
 Extension::Extension(const char* name,
                      const char* source,
                      int dep_count,
                      const char** deps)
@@ skipping 115 matching lines @@
 
 i::Object** v8::HandleScope::CreateHandle(i::Object* value) {
   return i::HandleScope::CreateHandle(value);
 }
 
 
 void Context::Enter() {
   if (IsDeadCheck("v8::Context::Enter()")) return;
   ENTER_V8;
   i::Handle<i::Context> env = Utils::OpenHandle(this);
+  i::HandleScopeImplementer& thread_local =
+    v8_context()->handle_scope_implementer_;
   thread_local.EnterContext(env);
 
   thread_local.SaveContext(i::Top::context());
   i::Top::set_context(*env);
 }
 
 
 void Context::Exit() {
   if (!i::V8::IsRunning()) return;
+  i::HandleScopeImplementer& thread_local =
+    v8_context()->handle_scope_implementer_;
   if (!ApiCheck(thread_local.LeaveLastContext(),
                 "v8::Context::Exit()",
                 "Cannot exit non-entered context")) {
     return;
   }
 
   // Content of 'last_context' could be NULL.
   i::Context* last_context = thread_local.RestoreContext();
   i::Top::set_context(last_context);
 }
@@ skipping 163 matching lines @@
 }
 
 
 void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) {
   if (IsDeadCheck("v8::FunctionTemplate::Inherit()")) return;
   ENTER_V8;
   Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value));
 }
 
 
-// To distinguish the function templates, so that we can find them in the
-// function cache of the global context.
-static int next_serial_number = 0;
 
 
 Local<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback,
     v8::Handle<Value> data, v8::Handle<Signature> signature) {
   EnsureInitialized("v8::FunctionTemplate::New()");
   LOG_API("FunctionTemplate::New");
   ENTER_V8;
   i::Handle<i::Struct> struct_obj =
       i::Factory::NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE);
   i::Handle<i::FunctionTemplateInfo> obj =
       i::Handle<i::FunctionTemplateInfo>::cast(struct_obj);
   InitializeFunctionTemplate(obj);
-  obj->set_serial_number(i::Smi::FromInt(next_serial_number++));
+  obj->set_serial_number(i::Smi::FromInt(
+    v8_context()->api_data_.next_serial_number_++));
   if (callback != 0) {
     if (data.IsEmpty()) data = v8::Undefined();
     Utils::ToLocal(obj)->SetCallHandler(callback, data);
   }
   obj->set_undetectable(false);
   obj->set_needs_access_check(false);
 
   if (!signature.IsEmpty())
     obj->set_signature(*Utils::OpenHandle(*signature));
   return Utils::ToLocal(obj);
@@ skipping 1762 matching lines @@
   if (IsDeadCheck("v8::String::Utf8Length()")) return 0;
   return Utils::OpenHandle(this)->Utf8Length();
 }
 
 
 int String::WriteUtf8(char* buffer, int capacity) const {
   if (IsDeadCheck("v8::String::WriteUtf8()")) return 0;
   LOG_API("String::WriteUtf8");
   ENTER_V8;
   i::Handle<i::String> str = Utils::OpenHandle(this);
+  i::StringInputBuffer& write_input_buffer =
+    v8_context()->api_data_.write_input_buffer_;
   write_input_buffer.Reset(0, *str);
   int len = str->length();
   // Encode the first K - 3 bytes directly into the buffer since we
   // know there's room for them.  If no capacity is given we copy all
   // of them here.
   int fast_end = capacity - (unibrow::Utf8::kMaxEncodedSize - 1);
   int i;
   int pos = 0;
   for (i = 0; i < len && (capacity == -1 || pos < fast_end); i++) {
     i::uc32 c = write_input_buffer.GetNext();
@@ skipping 30 matching lines @@
   ENTER_V8;
   ASSERT(start >= 0 && length >= -1);
   i::Handle<i::String> str = Utils::OpenHandle(this);
   // Flatten the string for efficiency.  This applies whether we are
   // using StringInputBuffer or Get(i) to access the characters.
   str->TryFlattenIfNotFlat();
   int end = length;
   if ( (length == -1) || (length > str->length() - start) )
     end = str->length() - start;
   if (end < 0) return 0;
+  i::StringInputBuffer& write_input_buffer = v8_context()->api_data_.
+    write_input_buffer_;
   write_input_buffer.Reset(start, *str);
   int i;
   for (i = 0; i < end; i++) {
     char c = static_cast<char>(write_input_buffer.GetNext());
     if (c == '\0') c = ' ';
     buffer[i] = c;
   }
   if (length == -1 || i < length)
     buffer[i] = '\0';
   return i;
@@ skipping 181 matching lines @@
 }
 
 
 void v8::V8::LowMemoryNotification() {
   if (!i::V8::IsRunning()) return;
   i::Heap::CollectAllGarbage(true);
 }
 
 
 const char* v8::V8::GetVersion() {
-  static v8::internal::EmbeddedVector<char, 128> buffer;
+  v8::internal::EmbeddedVector<char, 128>& buffer =
+    v8_context()->api_data_.buffer_;
   v8::internal::Version::GetString(buffer);
   return buffer.start();
 }
 
 
 static i::Handle<i::FunctionTemplateInfo>
     EnsureConstructor(i::Handle<i::ObjectTemplateInfo> templ) {
   if (templ->constructor()->IsUndefined()) {
     Local<FunctionTemplate> constructor = FunctionTemplate::New();
     Utils::OpenHandle(*constructor)->set_instance_template(*templ);
@@ skipping 111 matching lines @@
 }
 
 
 bool Context::InContext() {
   return i::Top::context() != NULL;
 }
 
 
 v8::Local<v8::Context> Context::GetEntered() {
   if (IsDeadCheck("v8::Context::GetEntered()")) return Local<Context>();
-  i::Handle<i::Object> last = thread_local.LastEnteredContext();
+  i::Handle<i::Object> last =
+    v8_context()->handle_scope_implementer_.LastEnteredContext();
   if (last.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(last);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Context> Context::GetCurrent() {
   if (IsDeadCheck("v8::Context::GetCurrent()")) return Local<Context>();
   i::Handle<i::Object> current = i::Top::global_context();
   if (current.is_null()) return Local<Context>();
@@ skipping 231 matching lines @@
 
   // External symbols are deleted when they are pruned out of the symbol
   // table. Generally external symbols are not registered with the weak handle
   // callbacks unless they are upgraded to a symbol after being externalized.
   if (!str->IsSymbol()) {
     v8::String::ExternalStringResource* resource =
         reinterpret_cast<v8::String::ExternalStringResource*>(parameter);
     if (resource != NULL) {
       const int total_size =
           static_cast<int>(resource->length() * sizeof(*resource->data()));
-      i::Counters::total_external_string_memory.Decrement(total_size);
+      DECREMENT_COUNTER(total_external_string_memory, total_size);
 
       // The object will continue to live in the JavaScript heap until the
       // handle is entirely cleaned out by the next GC. For example the
       // destructor for the resource below could bring it back to life again.
       // Which is why we make sure to not have a dangling pointer here.
       str->set_resource(NULL);
       delete resource;
     }
   }
 
@@ skipping 10 matching lines @@
 
   // External symbols are deleted when they are pruned out of the symbol
   // table. Generally external symbols are not registered with the weak handle
   // callbacks unless they are upgraded to a symbol after being externalized.
   if (!str->IsSymbol()) {
     v8::String::ExternalAsciiStringResource* resource =
         reinterpret_cast<v8::String::ExternalAsciiStringResource*>(parameter);
     if (resource != NULL) {
       const int total_size =
           static_cast<int>(resource->length() * sizeof(*resource->data()));
-      i::Counters::total_external_string_memory.Decrement(total_size);
+      DECREMENT_COUNTER(total_external_string_memory, total_size);
 
       // The object will continue to live in the JavaScript heap until the
       // handle is entirely cleaned out by the next GC. For example the
       // destructor for the resource below could bring it back to life again.
       // Which is why we make sure to not have a dangling pointer here.
       str->set_resource(NULL);
       delete resource;
     }
   }
 
   // In any case we do not need this handle any longer.
   obj.Dispose();
 }
 
 
 Local<String> v8::String::NewExternal(
       v8::String::ExternalStringResource* resource) {
   EnsureInitialized("v8::String::NewExternal()");
   LOG_API("String::NewExternal");
   ENTER_V8;
   const int total_size =
       static_cast<int>(resource->length() * sizeof(*resource->data()));
-  i::Counters::total_external_string_memory.Increment(total_size);
+  INCREMENT_COUNTER(total_external_string_memory, total_size);
   i::Handle<i::String> result = NewExternalStringHandle(resource);
   i::Handle<i::Object> handle = i::GlobalHandles::Create(*result);
   i::GlobalHandles::MakeWeak(handle.location(),
                              resource,
                              &DisposeExternalString);
   return Utils::ToLocal(result);
 }
 
 
 bool v8::String::MakeExternal(v8::String::ExternalStringResource* resource) {
@@ skipping 15 matching lines @@
 }
 
 
 Local<String> v8::String::NewExternal(
       v8::String::ExternalAsciiStringResource* resource) {
   EnsureInitialized("v8::String::NewExternal()");
   LOG_API("String::NewExternal");
   ENTER_V8;
   const int total_size =
       static_cast<int>(resource->length() * sizeof(*resource->data()));
-  i::Counters::total_external_string_memory.Increment(total_size);
+  INCREMENT_COUNTER(total_external_string_memory, total_size);
   i::Handle<i::String> result = NewExternalAsciiStringHandle(resource);
   i::Handle<i::Object> handle = i::GlobalHandles::Create(*result);
   i::GlobalHandles::MakeWeak(handle.location(),
                              resource,
                              &DisposeExternalAsciiString);
   return Utils::ToLocal(result);
 }
 
 
 bool v8::String::MakeExternal(
@@ skipping 142 matching lines @@
   if (fits_into_int32_t) {
     return Integer::New(static_cast<int32_t>(value));
   }
   ENTER_V8;
   i::Handle<i::Object> result = i::Factory::NewNumber(value);
   return Utils::IntegerToLocal(result);
 }
 
 
 void V8::IgnoreOutOfMemoryException() {
-  thread_local.set_ignore_out_of_memory(true);
+  v8_context()->handle_scope_implementer_.set_ignore_out_of_memory(true);
 }
 
 
 bool V8::AddMessageListener(MessageCallback that, Handle<Value> data) {
   EnsureInitialized("v8::V8::AddMessageListener()");
   ON_BAILOUT("v8::V8::AddMessageListener()", return false);
   ENTER_V8;
   HandleScope scope;
   NeanderArray listeners(i::Factory::message_listeners());
   NeanderObject obj(2);
@@ skipping 465 matching lines @@
 
 bool Debug::EnableAgent(const char* name, int port) {
   return i::Debugger::StartAgent(name, port);
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 namespace internal {
 
 
 HandleScopeImplementer* HandleScopeImplementer::instance() {
-  return &thread_local;
+  return &v8_context()->handle_scope_implementer_;
 }
 
 
 void HandleScopeImplementer::FreeThreadResources() {
-  thread_local.Free();
+  v8_context()->handle_scope_implementer_.Free();
 }
 
 
 char* HandleScopeImplementer::ArchiveThread(char* storage) {
-  return thread_local.ArchiveThreadHelper(storage);
+  return v8_context()->handle_scope_implementer_.ArchiveThreadHelper(storage);
 }
 
 
 char* HandleScopeImplementer::ArchiveThreadHelper(char* storage) {
   v8::ImplementationUtilities::HandleScopeData* current =
       v8::ImplementationUtilities::CurrentHandleScope();
   handle_scope_data_ = *current;
   memcpy(storage, this, sizeof(*this));
 
   ResetAfterArchive();
   current->Initialize();
 
   return storage + ArchiveSpacePerThread();
 }
 
 
 int HandleScopeImplementer::ArchiveSpacePerThread() {
-  return sizeof(thread_local);
+  return sizeof(HandleScopeImplementer);
 }
 
 
 char* HandleScopeImplementer::RestoreThread(char* storage) {
-  return thread_local.RestoreThreadHelper(storage);
+  return v8_context()->handle_scope_implementer_.RestoreThreadHelper(storage);
 }
 
 
 char* HandleScopeImplementer::RestoreThreadHelper(char* storage) {
   memcpy(this, storage, sizeof(*this));
   *v8::ImplementationUtilities::CurrentHandleScope() = handle_scope_data_;
   return storage + ArchiveSpacePerThread();
 }
 
 
@@ skipping 12 matching lines @@
   if (!saved_contexts_.is_empty()) {
     Object** start = reinterpret_cast<Object**>(&saved_contexts_.first());
     v->VisitPointers(start, start + saved_contexts_.length());
   }
 }
 
 
 void HandleScopeImplementer::Iterate(ObjectVisitor* v) {
   v8::ImplementationUtilities::HandleScopeData* current =
       v8::ImplementationUtilities::CurrentHandleScope();
-  thread_local.handle_scope_data_ = *current;
-  thread_local.IterateThis(v);
+  HandleScopeImplementer& handle_scope_implementer =
+    v8_context()->handle_scope_implementer_;
+  handle_scope_implementer.handle_scope_data_ = *current;
+  handle_scope_implementer.IterateThis(v);
 }
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal