Move RootIndexMap out of serializer file.

src/snapshot/serialize.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_SNAPSHOT_SERIALIZE_H_
 #define V8_SNAPSHOT_SERIALIZE_H_
 
-#include "src/hashmap.h"
+#include "src/address-map.h"
 #include "src/heap/heap.h"
 #include "src/objects.h"
 #include "src/snapshot/snapshot-source-sink.h"
 
 namespace v8 {
 namespace internal {
 
 class Isolate;
 class ScriptData;
 
@@ skipping 44 matching lines @@
     return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(key) >>
                                  kPointerSizeLog2);
   }
 
   HashMap* map_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalReferenceEncoder);
 };
 
 
-class AddressMapBase {
- protected:
-  static void SetValue(HashMap::Entry* entry, uint32_t v) {
-    entry->value = reinterpret_cast<void*>(v);
-  }
-
-  static uint32_t GetValue(HashMap::Entry* entry) {
-    return static_cast<uint32_t>(reinterpret_cast<intptr_t>(entry->value));
-  }
-
-  inline static HashMap::Entry* LookupEntry(HashMap* map, HeapObject* obj,
-                                            bool insert) {
-    if (insert) {
-      map->LookupOrInsert(Key(obj), Hash(obj));
-    }
-    return map->Lookup(Key(obj), Hash(obj));
-  }
-
- private:
-  static uint32_t Hash(HeapObject* obj) {
-    return static_cast<int32_t>(reinterpret_cast<intptr_t>(obj->address()));
-  }
-
-  static void* Key(HeapObject* obj) {
-    return reinterpret_cast<void*>(obj->address());
-  }
-};
-
-
-class RootIndexMap : public AddressMapBase {
- public:
-  explicit RootIndexMap(Isolate* isolate);
-
-  static const int kInvalidRootIndex = -1;
-
-  int Lookup(HeapObject* obj) {
-    HashMap::Entry* entry = LookupEntry(map_, obj, false);
-    if (entry) return GetValue(entry);
-    return kInvalidRootIndex;
-  }
-
- private:
-  HashMap* map_;
-
-  DISALLOW_COPY_AND_ASSIGN(RootIndexMap);
-};
-
-
 class PartialCacheIndexMap : public AddressMapBase {
  public:
   PartialCacheIndexMap() : map_(HashMap::PointersMatch) {}
 
   static const int kInvalidIndex = -1;
 
   // Lookup object in the map. Return its index if found, or create
   // a new entry with new_index as value, and return kInvalidIndex.
   int LookupOrInsert(HeapObject* obj, int new_index) {
     HashMap::Entry* entry = LookupEntry(&map_, obj, false);
     if (entry != NULL) return GetValue(entry);
     SetValue(LookupEntry(&map_, obj, true), static_cast<uint32_t>(new_index));
     return kInvalidIndex;
   }
 
  private:
   HashMap map_;
 
   DISALLOW_COPY_AND_ASSIGN(PartialCacheIndexMap);
 };
 
 
-class BackReference {
- public:
-  explicit BackReference(uint32_t bitfield) : bitfield_(bitfield) {}
-
-  BackReference() : bitfield_(kInvalidValue) {}
-
-  static BackReference SourceReference() { return BackReference(kSourceValue); }
-
-  static BackReference GlobalProxyReference() {
-    return BackReference(kGlobalProxyValue);
-  }
-
-  static BackReference LargeObjectReference(uint32_t index) {
-    return BackReference(SpaceBits::encode(LO_SPACE) |
-                         ChunkOffsetBits::encode(index));
-  }
-
-  static BackReference DummyReference() { return BackReference(kDummyValue); }
-
-  static BackReference Reference(AllocationSpace space, uint32_t chunk_index,
-                                 uint32_t chunk_offset) {
-    DCHECK(IsAligned(chunk_offset, kObjectAlignment));
-    DCHECK_NE(LO_SPACE, space);
-    return BackReference(
-        SpaceBits::encode(space) | ChunkIndexBits::encode(chunk_index) |
-        ChunkOffsetBits::encode(chunk_offset >> kObjectAlignmentBits));
-  }
-
-  bool is_valid() const { return bitfield_ != kInvalidValue; }
-  bool is_source() const { return bitfield_ == kSourceValue; }
-  bool is_global_proxy() const { return bitfield_ == kGlobalProxyValue; }
-
-  AllocationSpace space() const {
-    DCHECK(is_valid());
-    return SpaceBits::decode(bitfield_);
-  }
-
-  uint32_t chunk_offset() const {
-    DCHECK(is_valid());
-    return ChunkOffsetBits::decode(bitfield_) << kObjectAlignmentBits;
-  }
-
-  uint32_t large_object_index() const {
-    DCHECK(is_valid());
-    DCHECK(chunk_index() == 0);
-    return ChunkOffsetBits::decode(bitfield_);
-  }
-
-  uint32_t chunk_index() const {
-    DCHECK(is_valid());
-    return ChunkIndexBits::decode(bitfield_);
-  }
-
-  uint32_t reference() const {
-    DCHECK(is_valid());
-    return bitfield_ & (ChunkOffsetBits::kMask | ChunkIndexBits::kMask);
-  }
-
-  uint32_t bitfield() const { return bitfield_; }
-
- private:
-  static const uint32_t kInvalidValue = 0xFFFFFFFF;
-  static const uint32_t kSourceValue = 0xFFFFFFFE;
-  static const uint32_t kGlobalProxyValue = 0xFFFFFFFD;
-  static const uint32_t kDummyValue = 0xFFFFFFFC;
-  static const int kChunkOffsetSize = kPageSizeBits - kObjectAlignmentBits;
-  static const int kChunkIndexSize = 32 - kChunkOffsetSize - kSpaceTagSize;
-
- public:
-  static const int kMaxChunkIndex = (1 << kChunkIndexSize) - 1;
-
- private:
-  class ChunkOffsetBits : public BitField<uint32_t, 0, kChunkOffsetSize> {};
-  class ChunkIndexBits
-      : public BitField<uint32_t, ChunkOffsetBits::kNext, kChunkIndexSize> {};
-  class SpaceBits
-      : public BitField<AllocationSpace, ChunkIndexBits::kNext, kSpaceTagSize> {
-  };
-
-  uint32_t bitfield_;
-};
-
-
-// Mapping objects to their location after deserialization.
-// This is used during building, but not at runtime by V8.
-class BackReferenceMap : public AddressMapBase {
- public:
-  BackReferenceMap()
-      : no_allocation_(), map_(new HashMap(HashMap::PointersMatch)) {}
-
-  ~BackReferenceMap() { delete map_; }
-
-  BackReference Lookup(HeapObject* obj) {
-    HashMap::Entry* entry = LookupEntry(map_, obj, false);
-    return entry ? BackReference(GetValue(entry)) : BackReference();
-  }
-
-  void Add(HeapObject* obj, BackReference b) {
-    DCHECK(b.is_valid());
-    DCHECK_NULL(LookupEntry(map_, obj, false));
-    HashMap::Entry* entry = LookupEntry(map_, obj, true);
-    SetValue(entry, b.bitfield());
-  }
-
-  void AddSourceString(String* string) {
-    Add(string, BackReference::SourceReference());
-  }
-
-  void AddGlobalProxy(HeapObject* global_proxy) {
-    Add(global_proxy, BackReference::GlobalProxyReference());
-  }
-
- private:
-  DisallowHeapAllocation no_allocation_;
-  HashMap* map_;
-  DISALLOW_COPY_AND_ASSIGN(BackReferenceMap);
-};
-
-
 class HotObjectsList {
  public:
   HotObjectsList() : index_(0) {
     for (int i = 0; i < kSize; i++) circular_queue_[i] = NULL;
   }
 
   void Add(HeapObject* object) {
     circular_queue_[index_] = object;
     index_ = (index_ + 1) & kSizeMask;
   }
@@ skipping 704 matching lines @@
   static const int kNumCodeStubKeysOffset = kNumReservationsOffset + kInt32Size;
   static const int kPayloadLengthOffset = kNumCodeStubKeysOffset + kInt32Size;
   static const int kChecksum1Offset = kPayloadLengthOffset + kInt32Size;
   static const int kChecksum2Offset = kChecksum1Offset + kInt32Size;
   static const int kHeaderSize = kChecksum2Offset + kInt32Size;
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SNAPSHOT_SERIALIZE_H_