[serializer] cosmetic changes to SerializerReference.

src/address-map.h

 // Copyright 2015 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_ADDRESS_MAP_H_
 #define V8_ADDRESS_MAP_H_
 
 #include "src/assert-scope.h"
 #include "src/hashmap.h"
 #include "src/objects.h"
@@ skipping 42 matching lines @@
   }
 
  private:
   HashMap* map_;
 
   DISALLOW_COPY_AND_ASSIGN(RootIndexMap);
 };
 
 class SerializerReference {
  public:
-  explicit SerializerReference(uint32_t bitfield) : bitfield_(bitfield) {}
   SerializerReference() : bitfield_(Special(kInvalidValue)) {}
 
+  static SerializerReference FromBitfield(uint32_t bitfield) {
+    return SerializerReference(bitfield);
+  }
+
   static SerializerReference BackReference(AllocationSpace space,
                                            uint32_t chunk_index,
                                            uint32_t chunk_offset) {
     DCHECK(IsAligned(chunk_offset, kObjectAlignment));
     DCHECK_NE(LO_SPACE, space);
     return SerializerReference(
         SpaceBits::encode(space) | ChunkIndexBits::encode(chunk_index) |
         ChunkOffsetBits::encode(chunk_offset >> kObjectAlignmentBits));
   }
 
@@ skipping 46 matching lines @@
   bool is_attached_reference() const {
     return SpaceBits::decode(bitfield_) == kAttachedReferenceSpace;
   }
 
   int attached_reference_index() const {
     DCHECK(is_attached_reference());
     return ValueIndexBits::decode(bitfield_);
   }
 
  private:
+  explicit SerializerReference(uint32_t bitfield) : bitfield_(bitfield) {}
+
   inline static uint32_t Special(int value) {
     return SpaceBits::encode(kSpecialValueSpace) |
            ValueIndexBits::encode(value);
   }
 
   // We use the 32-bit bitfield to encode either a back reference, a special
-  // value, or a attached reference index.
+  // value, or an attached reference index.
   // Back reference:
   //   [ Space index             ] [ Chunk index ] [ Chunk offset ]
   //   [ LO_SPACE                ] [ large object index           ]
   // Special value
   //   [ kSpecialValueSpace      ] [ Special value index          ]
   // Attached reference
   //   [ kAttachedReferenceSpace ] [ Attached reference index     ]
 
   static const int kChunkOffsetSize = kPageSizeBits - kObjectAlignmentBits;
   static const int kChunkIndexSize = 32 - kChunkOffsetSize - kSpaceTagSize;
   static const int kValueIndexSize = kChunkOffsetSize + kChunkIndexSize;
 
   static const int kSpecialValueSpace = LAST_SPACE + 1;
   static const int kAttachedReferenceSpace = kSpecialValueSpace + 1;
   STATIC_ASSERT(kAttachedReferenceSpace < (1 << kSpaceTagSize));
 
   static const int kInvalidValue = 0;
   static const int kDummyValue = 1;
 
   // The chunk offset can also be used to encode the index of special values.
   class ChunkOffsetBits : public BitField<uint32_t, 0, kChunkOffsetSize> {};
   class ChunkIndexBits
       : public BitField<uint32_t, ChunkOffsetBits::kNext, kChunkIndexSize> {};
   class ValueIndexBits : public BitField<uint32_t, 0, kValueIndexSize> {};
+  STATIC_ASSERT(ChunkIndexBits::kNext == ValueIndexBits::kNext);
   class SpaceBits : public BitField<int, kValueIndexSize, kSpaceTagSize> {};
   STATIC_ASSERT(SpaceBits::kNext == 32);
 
   uint32_t bitfield_;
 
   friend class SerializerReferenceMap;
 };
 
 // Mapping objects to their location after deserialization.
 // This is used during building, but not at runtime by V8.
 class SerializerReferenceMap : public AddressMapBase {
  public:
   SerializerReferenceMap()
       : no_allocation_(),
-        map_(new HashMap(HashMap::PointersMatch)),
+        map_(HashMap::PointersMatch),
         attached_reference_index_(0) {}
 
-  ~SerializerReferenceMap() { delete map_; }
-
   SerializerReference Lookup(HeapObject* obj) {
-    HashMap::Entry* entry = LookupEntry(map_, obj, false);
+    HashMap::Entry* entry = LookupEntry(&map_, obj, false);
     return entry ? SerializerReference(GetValue(entry)) : SerializerReference();
   }
 
   void Add(HeapObject* obj, SerializerReference b) {
     DCHECK(b.is_valid());
-    DCHECK_NULL(LookupEntry(map_, obj, false));
-    HashMap::Entry* entry = LookupEntry(map_, obj, true);
+    DCHECK_NULL(LookupEntry(&map_, obj, false));
+    HashMap::Entry* entry = LookupEntry(&map_, obj, true);
     SetValue(entry, b.bitfield_);
   }
 
   SerializerReference AddAttachedReference(HeapObject* attached_reference) {
     SerializerReference reference =
         SerializerReference::AttachedReference(attached_reference_index_++);
     Add(attached_reference, reference);
     return reference;
   }
 
  private:
   DisallowHeapAllocation no_allocation_;
-  HashMap* map_;
+  HashMap map_;
   int attached_reference_index_;
   DISALLOW_COPY_AND_ASSIGN(SerializerReferenceMap);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_ADDRESS_MAP_H_