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

src/scopeinfo.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 518 matching lines @@
     number_of_locals += number_of_context_slots() - Context::MIN_CONTEXT_SLOTS;
   }
   return number_of_locals;
 }
 
 
 int ContextSlotCache::Hash(Code* code, String* name) {
   // Uses only lower 32 bits if pointers are larger.
   uintptr_t addr_hash =
       static_cast<uint32_t>(reinterpret_cast<uintptr_t>(code)) >> 2;
-  return (addr_hash ^ name->Hash()) % kLength;
+  return (addr_hash ^ name->Hash()) % ContextSlotCacheData::kLength;
 }
 
 
 int ContextSlotCache::Lookup(Code* code,
                              String* name,
                              Variable::Mode* mode) {
   int index = Hash(code, name);
-  Key& key = keys_[index];
+  ContextSlotCacheData& data = v8_context()->context_slot_cache_data_;
+  ContextSlotCacheData::Key& key = data.keys_[index];
   if ((key.code == code) && key.name->Equals(name)) {
-    Value result(values_[index]);
+    Value result(data.values_[index]);
     if (mode != NULL) *mode = result.mode();
     return result.index() + kNotFound;
   }
   return kNotFound;
 }
 
 
 void ContextSlotCache::Update(Code* code,
                               String* name,
                               Variable::Mode mode,
                               int slot_index) {
   String* symbol;
   ASSERT(slot_index > kNotFound);
   if (Heap::LookupSymbolIfExists(name, &symbol)) {
     int index = Hash(code, symbol);
-    Key& key = keys_[index];
+    ContextSlotCacheData& data = v8_context()->context_slot_cache_data_;
+    ContextSlotCacheData::Key& key = data.keys_[index];
     key.code = code;
     key.name = symbol;
     // Please note value only takes a uint as index.
-    values_[index] = Value(mode, slot_index - kNotFound).raw();
+    data.values_[index] = Value(mode, slot_index - kNotFound).raw();
 #ifdef DEBUG
     ValidateEntry(code, name, mode, slot_index);
 #endif
   }
 }
 
 
 void ContextSlotCache::Clear() {
-  for (int index = 0; index < kLength; index++) keys_[index].code = NULL;
+  ContextSlotCacheData& data = v8_context()->context_slot_cache_data_;
+  for (int index = 0; index < ContextSlotCacheData::kLength; index++)
+    data.keys_[index].code = NULL;
 }
 
-
-ContextSlotCache::Key ContextSlotCache::keys_[ContextSlotCache::kLength];
-
-
-uint32_t ContextSlotCache::values_[ContextSlotCache::kLength];
-
+ContextSlotCacheData::ContextSlotCacheData() {
+  for (int i = 0; i < ContextSlotCacheData::kLength; ++i) {
+    keys_[i].code = NULL;
+    keys_[i].name = NULL;
+    values_[i] = 0;
+  }
+}
 
 #ifdef DEBUG
 
 void ContextSlotCache::ValidateEntry(Code* code,
                                      String* name,
                                      Variable::Mode mode,
                                      int slot_index) {
   String* symbol;
   if (Heap::LookupSymbolIfExists(name, &symbol)) {
     int index = Hash(code, name);
-    Key& key = keys_[index];
+    ContextSlotCacheData& data = v8_context()->context_slot_cache_data_;
+    ContextSlotCacheData::Key& key = data.keys_[index];
     ASSERT(key.code == code);
     ASSERT(key.name->Equals(name));
-    Value result(values_[index]);
+    Value result(data.values_[index]);
     ASSERT(result.mode() == mode);
     ASSERT(result.index() + kNotFound == slot_index);
   }
 }
 
 
 template <class Allocator>
 static void PrintList(const char* list_name,
                       int nof_internal_slots,
                       List<Handle<String>, Allocator>& list) {
@@ skipping 29 matching lines @@
 }
 #endif  // DEBUG
 
 
 // Make sure the classes get instantiated by the template system.
 template class ScopeInfo<FreeStoreAllocationPolicy>;
 template class ScopeInfo<PreallocatedStorage>;
 template class ScopeInfo<ZoneListAllocationPolicy>;
 
 } }  // namespace v8::internal