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

src/objects.cc

 // Copyright 2006-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 2239 matching lines @@
   }
   new_map->set_unused_property_fields(0);
 
   // We have now successfully allocated all the necessary objects.
   // Changes can now be made with the guarantee that all of them take effect.
   set_map(new_map);
   map()->set_instance_descriptors(Heap::empty_descriptor_array());
 
   set_properties(dictionary);
 
-  Counters::props_to_dictionary.Increment();
+  INC_COUNTER(props_to_dictionary);
 
 #ifdef DEBUG
   if (FLAG_trace_normalization) {
     PrintF("Object properties have been normalized:\n");
     Print();
   }
 #endif
   return this;
 }
 
@@ skipping 26 matching lines @@
     if (!value->IsTheHole()) {
       PropertyDetails details = PropertyDetails(NONE, NORMAL);
       Object* result = dictionary->AddNumberEntry(i, array->get(i), details);
       if (result->IsFailure()) return result;
       dictionary = NumberDictionary::cast(result);
     }
   }
   // Switch to using the dictionary as the backing storage for elements.
   set_elements(dictionary);
 
-  Counters::elements_to_dictionary.Increment();
+  INC_COUNTER(elements_to_dictionary);
 
 #ifdef DEBUG
   if (FLAG_trace_normalization) {
     PrintF("Object elements have been normalized:\n");
     Print();
   }
 #endif
 
   return this;
 }
@@ skipping 1198 matching lines @@
   if (other->IsEmpty()) return false;
   if (length() != other->length()) return false;
   for (int i = 0; i < length(); ++i) {
     if (get(i) != other->get(i) && i != kContentArrayIndex) return false;
   }
   return GetContentArray()->IsEqualTo(other->GetContentArray());
 }
 #endif
 
 
-static StaticResource<StringInputBuffer> string_input_buffer;
 
 
 bool String::LooksValid() {
   if (!Heap::Contains(this)) return false;
   return true;
 }
 
 
 int String::Utf8Length() {
   if (IsAsciiRepresentation()) return length();
   // Attempt to flatten before accessing the string.  It probably
   // doesn't make Utf8Length faster, but it is very likely that
   // the string will be accessed later (for example by WriteUtf8)
   // so it's still a good idea.
   TryFlattenIfNotFlat();
-  Access<StringInputBuffer> buffer(&string_input_buffer);
+  Access<StringInputBuffer> buffer(&
+    v8_context()->objects_data_.string_input_buffer_);
   buffer->Reset(0, this);
   int result = 0;
   while (buffer->has_more())
     result += unibrow::Utf8::Length(buffer->GetNext());
   return result;
 }
 
 
 Vector<const char> String::ToAsciiVector() {
   ASSERT(IsAsciiRepresentation());
@@ skipping 54 matching lines @@
                                      int* length_return) {
   ASSERT(NativeAllocationChecker::allocation_allowed());
   if (robust_flag == ROBUST_STRING_TRAVERSAL && !LooksValid()) {
     return SmartPointer<char>(NULL);
   }
 
   // Negative length means the to the end of the string.
   if (length < 0) length = kMaxInt - offset;
 
   // Compute the size of the UTF-8 string. Start at the specified offset.
-  Access<StringInputBuffer> buffer(&string_input_buffer);
+  Access<StringInputBuffer> buffer(&
+    v8_context()->objects_data_.string_input_buffer_);
   buffer->Reset(offset, this);
   int character_position = offset;
   int utf8_bytes = 0;
   while (buffer->has_more()) {
     uint16_t character = buffer->GetNext();
     if (character_position < offset + length) {
       utf8_bytes += unibrow::Utf8::Length(character);
     }
     character_position++;
   }
@@ skipping 54 matching lines @@
 }
 
 
 SmartPointer<uc16> String::ToWideCString(RobustnessFlag robust_flag) {
   ASSERT(NativeAllocationChecker::allocation_allowed());
 
   if (robust_flag == ROBUST_STRING_TRAVERSAL && !LooksValid()) {
     return SmartPointer<uc16>();
   }
 
-  Access<StringInputBuffer> buffer(&string_input_buffer);
+  Access<StringInputBuffer> buffer(&
+    v8_context()->objects_data_.string_input_buffer_);
   buffer->Reset(this);
 
   uc16* result = NewArray<uc16>(length() + 1);
 
   int i = 0;
   while (buffer->has_more()) {
     uint16_t character = buffer->GetNext();
     result[i++] = character;
   }
   result[i] = 0;
@@ skipping 261 matching lines @@
         return rbb->util_buffer;
       }
     default:
       break;
   }
 
   UNREACHABLE();
   return 0;
 }
 
-
-Relocatable* Relocatable::top_ = NULL;
-
+RelocatableData::RelocatableData()
+  :top_(NULL) {
+}
 
 void Relocatable::PostGarbageCollectionProcessing() {
-  Relocatable* current = top_;
+  Relocatable* current = v8_context()->relocatable_data_.top_;
   while (current != NULL) {
     current->PostGarbageCollection();
     current = current->prev_;
   }
 }
 
 
 // Reserve space for statics needing saving and restoring.
 int Relocatable::ArchiveSpacePerThread() {
-  return sizeof(top_);
+  return sizeof(RelocatableData);
 }
 
 
 // Archive statics that are thread local.
 char* Relocatable::ArchiveState(char* to) {
-  *reinterpret_cast<Relocatable**>(to) = top_;
-  top_ = NULL;
+  Relocatable*& top = v8_context()->relocatable_data_.top_;
+  *reinterpret_cast<Relocatable**>(to) = top;
+  top = NULL;
   return to + ArchiveSpacePerThread();
 }
 
 
 // Restore statics that are thread local.
 char* Relocatable::RestoreState(char* from) {
-  top_ = *reinterpret_cast<Relocatable**>(from);
+  v8_context()->relocatable_data_.top_ = *reinterpret_cast<Relocatable**>(from);
   return from + ArchiveSpacePerThread();
 }
 
 
 char* Relocatable::Iterate(ObjectVisitor* v, char* thread_storage) {
   Relocatable* top = *reinterpret_cast<Relocatable**>(thread_storage);
   Iterate(v, top);
   return thread_storage + ArchiveSpacePerThread();
 }
 
 
 void Relocatable::Iterate(ObjectVisitor* v) {
-  Iterate(v, top_);
+  Iterate(v, v8_context()->relocatable_data_.top_);
 }
 
 
 void Relocatable::Iterate(ObjectVisitor* v, Relocatable* top) {
   Relocatable* current = top;
   while (current != NULL) {
     current->IterateInstance(v);
     current = current->prev_;
   }
 }
@@ skipping 358 matching lines @@
   // Compare the remaining characters that didn't fit into a block.
   for (; i < length; i++) {
     if (a[i] != b[i]) {
       return false;
     }
   }
   return true;
 }
 
 
-static StringInputBuffer string_compare_buffer_b;
 
 
 template <typename IteratorA>
 static inline bool CompareStringContentsPartial(IteratorA* ia, String* b) {
   if (b->IsFlat()) {
     if (b->IsAsciiRepresentation()) {
       VectorIterator<char> ib(b->ToAsciiVector());
       return CompareStringContents(ia, &ib);
     } else {
       VectorIterator<uc16> ib(b->ToUC16Vector());
       return CompareStringContents(ia, &ib);
     }
   } else {
+    StringInputBuffer& string_compare_buffer_b =
+      v8_context()->objects_data_.string_compare_buffer_b_;
     string_compare_buffer_b.Reset(0, b);
     return CompareStringContents(ia, &string_compare_buffer_b);
   }
 }
 
 
-static StringInputBuffer string_compare_buffer_a;
 
 
 bool String::SlowEquals(String* other) {
   // Fast check: negative check with lengths.
   int len = length();
   if (len != other->length()) return false;
   if (len == 0) return true;
 
   // Fast check: if hash code is computed for both strings
   // a fast negative check can be performed.
@@ skipping 16 matching lines @@
         if (other->IsAsciiRepresentation()) {
           Vector<const char> vec2 = other->ToAsciiVector();
           return CompareRawStringContents(vec1, vec2);
         } else {
           VectorIterator<char> buf1(vec1);
           VectorIterator<uc16> ib(other->ToUC16Vector());
           return CompareStringContents(&buf1, &ib);
         }
       } else {
         VectorIterator<char> buf1(vec1);
+        StringInputBuffer& string_compare_buffer_b =
+          v8_context()->objects_data_.string_compare_buffer_b_;
         string_compare_buffer_b.Reset(0, other);
         return CompareStringContents(&buf1, &string_compare_buffer_b);
       }
     } else {
       Vector<const uc16> vec1 = this->ToUC16Vector();
       if (other->IsFlat()) {
         if (other->IsAsciiRepresentation()) {
           VectorIterator<uc16> buf1(vec1);
           VectorIterator<char> ib(other->ToAsciiVector());
           return CompareStringContents(&buf1, &ib);
         } else {
           Vector<const uc16> vec2(other->ToUC16Vector());
           return CompareRawStringContents(vec1, vec2);
         }
       } else {
         VectorIterator<uc16> buf1(vec1);
+        StringInputBuffer& string_compare_buffer_b =
+          v8_context()->objects_data_.string_compare_buffer_b_;
         string_compare_buffer_b.Reset(0, other);
         return CompareStringContents(&buf1, &string_compare_buffer_b);
       }
     }
   } else {
+    StringInputBuffer& string_compare_buffer_a =
+      v8_context()->objects_data_.string_compare_buffer_a_;
     string_compare_buffer_a.Reset(0, this);
     return CompareStringContentsPartial(&string_compare_buffer_a, other);
   }
 }
 
 
 bool String::MarkAsUndetectable() {
   if (StringShape(this).IsSymbol()) return false;
 
   Map* map = this->map();
@@ skipping 3805 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal