Tweaks to the code serializer.

src/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_SERIALIZE_H_
 #define V8_SERIALIZE_H_
 
 #include "src/compiler.h"
 #include "src/hashmap.h"
 #include "src/heap-profiler.h"
@@ skipping 171 matching lines @@
   HashMap* map_;
 
   DISALLOW_COPY_AND_ASSIGN(RootIndexMap);
 };
 
 
 class BackReference {
  public:
   explicit BackReference(uint32_t bitfield) : bitfield_(bitfield) {}
 
-  BackReference(AllocationSpace space, uint32_t chunk_index,
-                uint32_t chunk_offset) {
-    DCHECK(IsAligned(chunk_offset, kObjectAlignment));
-    bitfield_ = SpaceBits::encode(space) | ChunkIndexBits::encode(chunk_index) |
-                ChunkOffsetBits::encode(chunk_offset >> kObjectAlignmentBits);
+  BackReference() : bitfield_(kInvalidValue) {}
+
+  static BackReference SourceReference() { return BackReference(kSourceValue); }
+
+  static BackReference LargeObjectReference(uint32_t index) {
+    return BackReference(SpaceBits::encode(LO_SPACE) |
+                         ChunkOffsetBits::encode(index));
   }
 
-  BackReference() : bitfield_(kInvalidValue) {}
+  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; }
 
   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 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 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> {};
@@ skipping 19 matching lines @@
     return entry ? BackReference(GetValue(entry)) : BackReference();
   }
 
   void Add(HeapObject* obj, BackReference b) {
     DCHECK(b.is_valid());
     DCHECK_EQ(NULL, LookupEntry(map_, obj, false));
     HashMap::Entry* entry = LookupEntry(map_, obj, true);
     SetValue(entry, b.bitfield());
   }
 
+  void AddSourceString(String* string) {
+    Add(string, BackReference::SourceReference());
+  }
+
  private:
   DisallowHeapAllocation no_allocation_;
   HashMap* map_;
   DISALLOW_COPY_AND_ASSIGN(BackReferenceMap);
 };
 
 
 // The Serializer/Deserializer class is a common superclass for Serializer and
 // Deserializer which is used to store common constants and methods used by
 // both.
@@ skipping 417 matching lines @@
 
   List<uint32_t>* stub_keys() { return &stub_keys_; }
   int num_internalized_strings() const { return num_internalized_strings_; }
 
  private:
   CodeSerializer(Isolate* isolate, SnapshotByteSink* sink, String* source,
                  Code* main_code)
       : Serializer(isolate, sink),
         source_(source),
         main_code_(main_code),
-        num_internalized_strings_(0) {}
+        num_internalized_strings_(0) {
+    back_reference_map_.AddSourceString(source);
+  }
 
   virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
                                WhereToPoint where_to_point, int skip);
 
   void SerializeBuiltin(int builtin_index, HowToCode how_to_code,
                         WhereToPoint where_to_point);
   void SerializeIC(Code* ic, HowToCode how_to_code,
                    WhereToPoint where_to_point);
   void SerializeCodeStub(uint32_t stub_key, HowToCode how_to_code,
                          WhereToPoint where_to_point);
@@ skipping 113 matching lines @@
   // Following the header, we store, in sequential order
   // - code stub keys
   // - serialization payload
 
   ScriptData* script_data_;
   bool owns_script_data_;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_