Serializer: commit new internalized strings after deserialization.

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/heap-profiler.h"
 #include "src/isolate.h"
@@ skipping 530 matching lines @@
 
   void FlushICacheForNewCodeObjects();
 
   // Pass a vector of externally-provided objects referenced by the snapshot.
   // The ownership to its backing store is handed over as well.
   void SetAttachedObjects(Vector<Handle<Object> > attached_objects) {
     attached_objects_ = attached_objects;
   }
 
  private:
+  class NewInternalizedStrings : public Relocatable {
+   public:
+    explicit NewInternalizedStrings(Isolate* isolate) : Relocatable(isolate) {}
+
+    virtual void IterateInstance(ObjectVisitor* v) {
+      Object** start = reinterpret_cast<Object**>(&strings_[0]);
+      v->VisitPointers(start, start + strings_.length());
+    }
+
+    void Add(String* string) { strings_.Add(string); }
+
+    void Commit(Isolate* isolate);
+
+   private:
+    List<String*> strings_;
+  };
+
   virtual void VisitPointers(Object** start, Object** end);
 
   virtual void VisitRuntimeEntry(RelocInfo* rinfo) {
     UNREACHABLE();
   }
 
   void Initialize(Isolate* isolate);
 
   bool deserializing_user_code() { return deserializing_user_code_; }
 
@@ skipping 38 matching lines @@
   // fitting into a page. Deserialized objects are allocated into the
   // current chunk of the target space by bumping up high water mark.
   Heap::Reservation reservations_[kNumberOfSpaces];
   uint32_t current_chunk_[kNumberOfPreallocatedSpaces];
   Address high_water_[kNumberOfPreallocatedSpaces];
 
   ExternalReferenceTable* external_reference_table_;
 
   List<HeapObject*> deserialized_large_objects_;
   List<Code*> new_code_objects_;
+  NewInternalizedStrings* new_internalized_strings_;
 
   bool deserializing_user_code_;
 
   AllocationAlignment next_alignment_;
 
   DISALLOW_COPY_AND_ASSIGN(Deserializer);
 };
 
 
 class CodeAddressMap;
@@ skipping 283 matching lines @@
   STATIC_ASSERT(kSourceObjectReference == kSourceObjectIndex);
 
   static const int kCodeStubsBaseIndex = 1;
 
   String* source() const {
     DCHECK(!AllowHeapAllocation::IsAllowed());
     return source_;
   }
 
   const List<uint32_t>* stub_keys() const { 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) {
+      : Serializer(isolate, sink), source_(source), main_code_(main_code) {
     back_reference_map_.AddSourceString(source);
   }
 
   ~CodeSerializer() { OutputStatistics("CodeSerializer"); }
 
   virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
                                WhereToPoint where_to_point, int skip) override;
 
   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);
   void SerializeGeneric(HeapObject* heap_object, HowToCode how_to_code,
                         WhereToPoint where_to_point);
   int AddCodeStubKey(uint32_t stub_key);
 
   DisallowHeapAllocation no_gc_;
   String* source_;
   Code* main_code_;
-  int num_internalized_strings_;
   List<uint32_t> stub_keys_;
   DISALLOW_COPY_AND_ASSIGN(CodeSerializer);
 };
 
 
 // Wrapper around reservation sizes and the serialization payload.
 class SnapshotData : public SerializedData {
  public:
   // Used when producing.
   explicit SnapshotData(const Serializer& ser);
@@ skipping 38 matching lines @@
 
   // Used when producing.
   SerializedCodeData(const List<byte>& payload, const CodeSerializer& cs);
 
   // Return ScriptData object and relinquish ownership over it to the caller.
   ScriptData* GetScriptData();
 
   Vector<const Reservation> Reservations() const;
   Vector<const byte> Payload() const;
 
-  int NumInternalizedStrings() const;
   Vector<const uint32_t> CodeStubKeys() const;
 
  private:
   explicit SerializedCodeData(ScriptData* data);
 
   enum SanityCheckResult {
     CHECK_SUCCESS = 0,
     MAGIC_NUMBER_MISMATCH = 1,
     VERSION_MISMATCH = 2,
     SOURCE_MISMATCH = 3,
     CPU_FEATURES_MISMATCH = 4,
     FLAGS_MISMATCH = 5,
     CHECKSUM_MISMATCH = 6
   };
 
   SanityCheckResult SanityCheck(Isolate* isolate, String* source) const;
 
   uint32_t SourceHash(String* source) const { return source->length(); }
 
   // The data header consists of uint32_t-sized entries:
-  // [ 0] magic number and external reference count
-  // [ 1] version hash
-  // [ 2] source hash
-  // [ 3] cpu features
-  // [ 4] flag hash
-  // [ 5] number of internalized strings
-  // [ 6] number of code stub keys
-  // [ 7] number of reservation size entries
-  // [ 8] payload length
-  // [ 9] payload checksum part 1
-  // [10] payload checksum part 2
+  // [0] magic number and external reference count
+  // [1] version hash
+  // [2] source hash
+  // [3] cpu features
+  // [4] flag hash
+  // [5] number of code stub keys
+  // [6] number of reservation size entries
+  // [7] payload length
+  // [8] payload checksum part 1
+  // [9] payload checksum part 2
   // ...  reservations
   // ...  code stub keys
   // ...  serialized payload
   static const int kVersionHashOffset = kMagicNumberOffset + kInt32Size;
   static const int kSourceHashOffset = kVersionHashOffset + kInt32Size;
   static const int kCpuFeaturesOffset = kSourceHashOffset + kInt32Size;
   static const int kFlagHashOffset = kCpuFeaturesOffset + kInt32Size;
-  static const int kNumInternalizedStringsOffset = kFlagHashOffset + kInt32Size;
-  static const int kNumReservationsOffset =
-      kNumInternalizedStringsOffset + kInt32Size;
+  static const int kNumReservationsOffset = kFlagHashOffset + kInt32Size;
   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 v8::internal
 
 #endif  // V8_SNAPSHOT_SERIALIZE_H_