Merge isolates to bleeding_edge.

src/serialize.h

 // 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 61 matching lines @@
   HashMap encodings_;
   static uint32_t Hash(Address key) {
     return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(key) >> 2);
   }
 
   int IndexOf(Address key) const;
 
   static bool Match(void* key1, void* key2) { return key1 == key2; }
 
   void Put(Address key, int index);
+
+  Isolate* isolate_;
 };
 
 
 class ExternalReferenceDecoder {
  public:
   ExternalReferenceDecoder();
   ~ExternalReferenceDecoder();
 
   Address Decode(uint32_t key) const {
     if (key == 0) return NULL;
     return *Lookup(key);
   }
 
  private:
   Address** encodings_;
 
   Address* Lookup(uint32_t key) const {
     int type = key >> kReferenceTypeShift;
     ASSERT(kFirstTypeCode <= type && type < kTypeCodeCount);
     int id = key & kReferenceIdMask;
     return &encodings_[type][id];
   }
 
   void Put(uint32_t key, Address value) {
     *Lookup(key) = value;
   }
+
+  Isolate* isolate_;
 };
 
 
 class SnapshotByteSource {
  public:
   SnapshotByteSource(const byte* array, int length)
     : data_(array), length_(length), position_(0) { }
 
   bool HasMore() { return position_ < length_; }
 
@@ skipping 19 matching lines @@
 };
 
 
 // It is very common to have a reference to objects at certain offsets in the
 // heap.  These offsets have been determined experimentally.  We code
 // references to such objects in a single byte that encodes the way the pointer
 // is written (only plain pointers allowed), the space number and the offset.
 // This only works for objects in the first page of a space.  Don't use this for
 // things in newspace since it bypasses the write barrier.
 
-static const int k64 = (sizeof(uintptr_t) - 4) / 4;
+RLYSTC const int k64 = (sizeof(uintptr_t) - 4) / 4;
 
 #define COMMON_REFERENCE_PATTERNS(f)                               \
   f(kNumberOfSpaces, 2, (11 - k64))                                \
   f((kNumberOfSpaces + 1), 2, 0)                                   \
   f((kNumberOfSpaces + 2), 2, (142 - 16 * k64))                    \
   f((kNumberOfSpaces + 3), 2, (74 - 15 * k64))                     \
   f((kNumberOfSpaces + 4), 2, 5)                                   \
   f((kNumberOfSpaces + 5), 1, 135)                                 \
   f((kNumberOfSpaces + 6), 2, (228 - 39 * k64))
 
@@ skipping 12 matching lines @@
   f(12, 24) \
   f(13, 28) \
   f(14, 32) \
   f(15, 36)
 
 // The Serializer/Deserializer class is a common superclass for Serializer and
 // Deserializer which is used to store common constants and methods used by
 // both.
 class SerializerDeserializer: public ObjectVisitor {
  public:
-  static void Iterate(ObjectVisitor* visitor);
-  static void SetSnapshotCacheSize(int size);
+  RLYSTC void Iterate(ObjectVisitor* visitor);
+  RLYSTC void SetSnapshotCacheSize(int size);
 
  protected:
   // Where the pointed-to object can be found:
   enum Where {
     kNewObject = 0,                 // Object is next in snapshot.
     // 1-8                             One per space.
     kRootArray = 0x9,               // Object is found in root array.
     kPartialSnapshotCache = 0xa,    // Object is in the cache.
     kExternalReference = 0xb,       // Pointer to an external reference.
     // 0xc-0xf                         Free.
@@ skipping 17 matching lines @@
 
   // Where to point within the object.
   enum WhereToPoint {
     kStartOfObject = 0,
     kFirstInstruction = 0x80,
     kWhereToPointMask = 0x80
   };
 
   // Misc.
   // Raw data to be copied from the snapshot.
-  static const int kRawData = 0x30;
+  RLYSTC const int kRawData = 0x30;
   // Some common raw lengths: 0x31-0x3f
   // A tag emitted at strategic points in the snapshot to delineate sections.
   // If the deserializer does not find these at the expected moments then it
   // is an indication that the snapshot and the VM do not fit together.
   // Examine the build process for architecture, version or configuration
   // mismatches.
-  static const int kSynchronize = 0x70;
+  RLYSTC const int kSynchronize = 0x70;
   // Used for the source code of the natives, which is in the executable, but
   // is referred to from external strings in the snapshot.
-  static const int kNativesStringResource = 0x71;
-  static const int kNewPage = 0x72;
+  RLYSTC const int kNativesStringResource = 0x71;
+  RLYSTC const int kNewPage = 0x72;
   // 0x73-0x7f                            Free.
   // 0xb0-0xbf                            Free.
   // 0xf0-0xff                            Free.
 
 
-  static const int kLargeData = LAST_SPACE;
-  static const int kLargeCode = kLargeData + 1;
-  static const int kLargeFixedArray = kLargeCode + 1;
-  static const int kNumberOfSpaces = kLargeFixedArray + 1;
-  static const int kAnyOldSpace = -1;
+  RLYSTC const int kLargeData = LAST_SPACE;
+  RLYSTC const int kLargeCode = kLargeData + 1;
+  RLYSTC const int kLargeFixedArray = kLargeCode + 1;
+  RLYSTC const int kNumberOfSpaces = kLargeFixedArray + 1;
+  RLYSTC const int kAnyOldSpace = -1;
 
   // A bitmask for getting the space out of an instruction.
-  static const int kSpaceMask = 15;
+  RLYSTC const int kSpaceMask = 15;
 
-  static inline bool SpaceIsLarge(int space) { return space >= kLargeData; }
-  static inline bool SpaceIsPaged(int space) {
+  RLYSTC inline bool SpaceIsLarge(int space) { return space >= kLargeData; }
+  RLYSTC inline bool SpaceIsPaged(int space) {
     return space >= FIRST_PAGED_SPACE && space <= LAST_PAGED_SPACE;
   }
-
-  static int partial_snapshot_cache_length_;
-  static const int kPartialSnapshotCacheCapacity = 1400;
-  static Object* partial_snapshot_cache_[];
 };
 
 
 int SnapshotByteSource::GetInt() {
   // A little unwind to catch the really small ints.
   int snapshot_byte = Get();
   if ((snapshot_byte & 0x80) == 0) {
     return snapshot_byte;
   }
   int accumulator = (snapshot_byte & 0x7f) << 7;
@@ skipping 43 matching lines @@
   virtual void VisitRuntimeEntry(RelocInfo* rinfo) {
     UNREACHABLE();
   }
 
   void ReadChunk(Object** start, Object** end, int space, Address address);
   HeapObject* GetAddressFromStart(int space);
   inline HeapObject* GetAddressFromEnd(int space);
   Address Allocate(int space_number, Space* space, int size);
   void ReadObject(int space_number, Space* space, Object** write_back);
 
+  // Cached current isolate.
+  Isolate* isolate_;
+
   // Keep track of the pages in the paged spaces.
   // (In large object space we are keeping track of individual objects
   // rather than pages.)  In new space we just need the address of the
   // first object and the others will flow from that.
   List<Address> pages_[SerializerDeserializer::kNumberOfSpaces];
 
   SnapshotByteSource* source_;
-  static ExternalReferenceDecoder* external_reference_decoder_;
   // This is the address of the next object that will be allocated in each
   // space.  It is used to calculate the addresses of back-references.
   Address high_water_[LAST_SPACE + 1];
   // This is the address of the most recent object that was allocated.  It
   // is used to set the location of the new page when we encounter a
   // START_NEW_PAGE_SERIALIZATION tag.
   Address last_object_address_;
 
+  ExternalReferenceDecoder* external_reference_decoder_;
+
   DISALLOW_COPY_AND_ASSIGN(Deserializer);
 };
 
 
 class SnapshotByteSink {
  public:
   virtual ~SnapshotByteSink() { }
   virtual void Put(int byte, const char* description) = 0;
   virtual void PutSection(int byte, const char* description) {
     Put(byte, description);
@@ skipping 27 matching lines @@
   }
 
   void AddMapping(HeapObject* obj, int to) {
     ASSERT(!IsMapped(obj));
     HashMap::Entry* entry =
         serialization_map_->Lookup(Key(obj), Hash(obj), true);
     entry->value = Value(to);
   }
 
  private:
-  static bool SerializationMatchFun(void* key1, void* key2) {
+  RLYSTC bool SerializationMatchFun(void* key1, void* key2) {
     return key1 == key2;
   }
 
-  static uint32_t Hash(HeapObject* obj) {
+  RLYSTC uint32_t Hash(HeapObject* obj) {
     return static_cast<int32_t>(reinterpret_cast<intptr_t>(obj->address()));
   }
 
-  static void* Key(HeapObject* obj) {
+  RLYSTC void* Key(HeapObject* obj) {
     return reinterpret_cast<void*>(obj->address());
   }
 
-  static void* Value(int v) {
+  RLYSTC void* Value(int v) {
     return reinterpret_cast<void*>(v);
   }
 
   HashMap* serialization_map_;
   AssertNoAllocation* no_allocation_;
   DISALLOW_COPY_AND_ASSIGN(SerializationAddressMapper);
 };
 
 
-class Serializer : public SerializerDeserializer {
+// There can be only one serializer per V8 process.
+STATIC_CLASS Serializer : public SerializerDeserializer {
  public:
   explicit Serializer(SnapshotByteSink* sink);
   ~Serializer();
   void VisitPointers(Object** start, Object** end);
   // You can call this after serialization to find out how much space was used
   // in each space.
   int CurrentAllocationAddress(int space) {
     if (SpaceIsLarge(space)) return large_object_total_;
     return fullness_[space];
   }
 
-  static void Enable() {
+  RLYSTC void Enable() {
     if (!serialization_enabled_) {
       ASSERT(!too_late_to_enable_now_);
     }
     serialization_enabled_ = true;
   }
 
-  static void Disable() { serialization_enabled_ = false; }
+  RLYSTC void Disable() { serialization_enabled_ = false; }
   // Call this when you have made use of the fact that there is no serialization
   // going on.
-  static void TooLateToEnableNow() { too_late_to_enable_now_ = true; }
-  static bool enabled() { return serialization_enabled_; }
+  RLYSTC void TooLateToEnableNow() { too_late_to_enable_now_ = true; }
+  RLYSTC bool enabled() { return serialization_enabled_; }
   SerializationAddressMapper* address_mapper() { return &address_mapper_; }
 #ifdef DEBUG
   virtual void Synchronize(const char* tag);
 #endif
 
  protected:
-  static const int kInvalidRootIndex = -1;
+  RLYSTC const int kInvalidRootIndex = -1;
   virtual int RootIndex(HeapObject* heap_object) = 0;
   virtual bool ShouldBeInThePartialSnapshotCache(HeapObject* o) = 0;
 
   class ObjectSerializer : public ObjectVisitor {
    public:
     ObjectSerializer(Serializer* serializer,
                      Object* o,
                      SnapshotByteSink* sink,
                      HowToCode how_to_code,
                      WhereToPoint where_to_point)
@@ skipping 34 matching lines @@
   void SerializeReferenceToPreviousObject(
       int space,
       int address,
       HowToCode how_to_code,
       WhereToPoint where_to_point);
   void InitializeAllocators();
   // This will return the space for an object.  If the object is in large
   // object space it may return kLargeCode or kLargeFixedArray in order
   // to indicate to the deserializer what kind of large object allocation
   // to make.
-  static int SpaceOfObject(HeapObject* object);
+  RLYSTC int SpaceOfObject(HeapObject* object);
   // This just returns the space of the object.  It will return LO_SPACE
   // for all large objects since you can't check the type of the object
   // once the map has been used for the serialization address.
-  static int SpaceOfAlreadySerializedObject(HeapObject* object);
+  RLYSTC int SpaceOfAlreadySerializedObject(HeapObject* object);
   int Allocate(int space, int size, bool* new_page_started);
   int EncodeExternalReference(Address addr) {
     return external_reference_encoder_->Encode(addr);
   }
 
   // Keep track of the fullness of each space in order to generate
   // relative addresses for back references.  Large objects are
   // just numbered sequentially since relative addresses make no
   // sense in large object space.
   int fullness_[LAST_SPACE + 1];
   SnapshotByteSink* sink_;
   int current_root_index_;
   ExternalReferenceEncoder* external_reference_encoder_;
-  static bool serialization_enabled_;
+  RLYSTC bool serialization_enabled_;
   // Did we already make use of the fact that serialization was not enabled?
-  static bool too_late_to_enable_now_;
+  RLYSTC bool too_late_to_enable_now_;
   int large_object_total_;
   SerializationAddressMapper address_mapper_;
 
   friend class ObjectSerializer;
   friend class Deserializer;
 
   DISALLOW_COPY_AND_ASSIGN(Serializer);
 };
 
 
@@ skipping 15 matching lines @@
   virtual int RootIndex(HeapObject* o);
   virtual int PartialSnapshotCacheIndex(HeapObject* o);
   virtual bool ShouldBeInThePartialSnapshotCache(HeapObject* o) {
     // Scripts should be referred only through shared function infos.  We can't
     // allow them to be part of the partial snapshot because they contain a
     // unique ID, and deserializing several partial snapshots containing script
     // would cause dupes.
     ASSERT(!o->IsScript());
     return o->IsString() || o->IsSharedFunctionInfo() ||
            o->IsHeapNumber() || o->IsCode() ||
-           o->map() == Heap::fixed_cow_array_map();
+           o->map() == HEAP->fixed_cow_array_map();
   }
 
  private:
   Serializer* startup_serializer_;
   DISALLOW_COPY_AND_ASSIGN(PartialSerializer);
 };
 
 
 class StartupSerializer : public Serializer {
  public:
   explicit StartupSerializer(SnapshotByteSink* sink) : Serializer(sink) {
     // Clear the cache of objects used by the partial snapshot.  After the
     // strong roots have been serialized we can create a partial snapshot
     // which will repopulate the cache with objects neede by that partial
     // snapshot.
-    partial_snapshot_cache_length_ = 0;
+    Isolate::Current()->set_serialize_partial_snapshot_cache_length(0);
   }
   // Serialize the current state of the heap.  The order is:
   // 1) Strong references.
   // 2) Partial snapshot cache.
   // 3) Weak references (eg the symbol table).
   virtual void SerializeStrongReferences();
   virtual void SerializeObject(Object* o,
                                HowToCode how_to_code,
                                WhereToPoint where_to_point);
   void SerializeWeakReferences();
   void Serialize() {
     SerializeStrongReferences();
     SerializeWeakReferences();
   }
 
  private:
   virtual int RootIndex(HeapObject* o) { return kInvalidRootIndex; }
   virtual bool ShouldBeInThePartialSnapshotCache(HeapObject* o) {
     return false;
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_