Fix up internalized strings after deserializing user code.

src/serialize.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 700 matching lines @@
     address_to_name_map_.Insert(code->address(), name, length);
   }
 
   NameMap address_to_name_map_;
   Isolate* isolate_;
 };
 
 
 Deserializer::Deserializer(SnapshotByteSource* source)
     : isolate_(NULL),
+      deserialize_code_(false),
       source_(source),
       external_reference_decoder_(NULL) {
   for (int i = 0; i < LAST_SPACE + 1; i++) {
     reservations_[i] = kUninitializedReservation;
   }
 }
 
 
 void Deserializer::FlushICacheForNewCodeObjects() {
   PageIterator it(isolate_->heap()->code_space());
@@ skipping 94 matching lines @@
 void Deserializer::RelinkAllocationSite(AllocationSite* site) {
   if (isolate_->heap()->allocation_sites_list() == Smi::FromInt(0)) {
     site->set_weak_next(isolate_->heap()->undefined_value());
   } else {
     site->set_weak_next(isolate_->heap()->allocation_sites_list());
   }
   isolate_->heap()->set_allocation_sites_list(site);
 }
 
 
+// Used to insert a deserialized internalized string into the string table.
+class StringTableInsertionKey : public HashTableKey {
+ public:
+  explicit StringTableInsertionKey(String* string)
+      : string_(string), hash_(HashForObject(string)) {
+    ASSERT(string->IsInternalizedString());
+  }
+
+  virtual bool IsMatch(Object* string) {
+    // We know that all entries in a hash table had their hash keys created.
+    // Use that knowledge to have fast failure.
+    if (hash_ != HashForObject(string)) return false;
+    // We want to compare the content of two internalized strings here.
+    return string_->SlowEquals(String::cast(string));
+  }
+
+  virtual uint32_t Hash() V8_OVERRIDE { return hash_; }
+
+  virtual uint32_t HashForObject(Object* key) V8_OVERRIDE {
+    return String::cast(key)->Hash();
+  }
+
+  MUST_USE_RESULT virtual Handle<Object> AsHandle(Isolate* isolate)
+      V8_OVERRIDE {
+    return handle(string_, isolate);
+  }
+
+  String* string_;
+  uint32_t hash_;
+};
+
+
+HeapObject* Deserializer::ProcessObjectFromSerializedCode(HeapObject* obj) {
+  if (obj->IsString()) {
+    String* string = String::cast(obj);
+    // Uninitialize hash field as the hash seed may have changed.
+    string->set_hash_field(String::kEmptyHashField);
+    if (string->IsInternalizedString()) {
+      DisallowHeapAllocation no_gc;
+      HandleScope scope(isolate_);
+      StringTableInsertionKey key(string);
+      return *StringTable::LookupKey(isolate_, &key);
+    }
+  }
+  return obj;
+}
+
+
 // This routine writes the new object into the pointer provided and then
 // returns true if the new object was in young space and false otherwise.
 // The reason for this strange interface is that otherwise the object is
 // written very late, which means the FreeSpace map is not set up by the
 // time we need to use it to mark the space at the end of a page free.
 void Deserializer::ReadObject(int space_number,
                               Object** write_back) {
   int size = source_->GetInt() << kObjectAlignmentBits;
   Address address = Allocate(space_number, size);
   HeapObject* obj = HeapObject::FromAddress(address);
   isolate_->heap()->OnAllocationEvent(obj, size);
-  *write_back = obj;
   Object** current = reinterpret_cast<Object**>(address);
   Object** limit = current + (size >> kPointerSizeLog2);
   if (FLAG_log_snapshot_positions) {
     LOG(isolate_, SnapshotPositionEvent(address, source_->position()));
   }
   ReadChunk(current, limit, space_number, address);
 
   // TODO(mvstanton): consider treating the heap()->allocation_sites_list()
   // as a (weak) root. If this root is relocated correctly,
   // RelinkAllocationSite() isn't necessary.
-  if (obj->IsAllocationSite()) {
-    RelinkAllocationSite(AllocationSite::cast(obj));
-  }
+  if (obj->IsAllocationSite()) RelinkAllocationSite(AllocationSite::cast(obj));
 
+  // Fix up strings from serialized user code.
+  if (deserialize_code_) obj = ProcessObjectFromSerializedCode(obj);
+
+  *write_back = obj;
 #ifdef DEBUG
   bool is_codespace = (space_number == CODE_SPACE);
   ASSERT(obj->IsCode() == is_codespace);
 #endif
 }
 
 void Deserializer::ReadChunk(Object** current,
                              Object** limit,
                              int source_space,
                              Address current_object_address) {
@@ skipping 43 matching lines @@
         int skip = source_->GetInt();                                          \
         current = reinterpret_cast<Object**>(                                  \
             reinterpret_cast<Address>(current) + skip);                        \
         int reference_id = source_->GetInt();                                  \
         Address address = external_reference_decoder_->Decode(reference_id);   \
         new_object = reinterpret_cast<Object*>(address);                       \
       } else if (where == kBackref) {                                          \
         emit_write_barrier = (space_number == NEW_SPACE);                      \
         new_object = GetAddressFromEnd(data & kSpaceMask);                     \
       } else if (where == kBuiltin) {                                          \
+        ASSERT(deserialize_code_);                                             \
         int builtin_id = source_->GetInt();                                    \
         ASSERT_LE(0, builtin_id);                                              \
         ASSERT_LT(builtin_id, Builtins::builtin_count);                        \
         Builtins::Name name = static_cast<Builtins::Name>(builtin_id);         \
         new_object = isolate->builtins()->builtin(name);                       \
         emit_write_barrier = false;                                            \
-        PrintF("BUILTIN how within %d, %d\n", how, within);                    \
       } else {                                                                 \
         ASSERT(where == kBackrefWithSkip);                                     \
         int skip = source_->GetInt();                                          \
         current = reinterpret_cast<Object**>(                                  \
             reinterpret_cast<Address>(current) + skip);                        \
         emit_write_barrier = (space_number == NEW_SPACE);                      \
         new_object = GetAddressFromEnd(data & kSpaceMask);                     \
       }                                                                        \
       if (within == kInnerPointer) {                                           \
         if (space_number != CODE_SPACE || new_object->IsCode()) {              \
@@ skipping 911 matching lines @@
              heap_object->GetHeap()->empty_fixed_array());
 
   int root_index;
   if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
     PutRoot(root_index, heap_object, how_to_code, where_to_point, skip);
     return;
   }
 
   // TODO(yangguo) wire up stubs from stub cache.
   // TODO(yangguo) wire up script source.
-  // TODO(yangguo) wire up internalized strings
-  ASSERT(!heap_object->IsInternalizedString());
   // TODO(yangguo) We cannot deal with different hash seeds yet.
   ASSERT(!heap_object->IsHashTable());
 
   if (heap_object->IsCode()) {
     Code* code_object = Code::cast(heap_object);
     if (code_object->kind() == Code::BUILTIN) {
       SerializeBuiltin(code_object, how_to_code, where_to_point, skip);
       return;
     }
   }
@@ skipping 35 matching lines @@
 
   sink_->Put(kBuiltin + how_to_code + where_to_point, "Builtin");
   sink_->PutInt(id, "builtin_index");
 }
 
 
 Object* CodeSerializer::Deserialize(Isolate* isolate, ScriptData* data) {
   SerializedCodeData scd(data);
   SnapshotByteSource payload(scd.Payload(), scd.PayloadLength());
   Deserializer deserializer(&payload);
+  deserializer.ExpectSerializedCode();
   STATIC_ASSERT(NEW_SPACE == 0);
   // TODO(yangguo) what happens if remaining new space is too small?
   for (int i = NEW_SPACE; i <= PROPERTY_CELL_SPACE; i++) {
     deserializer.set_reservation(i, scd.GetReservation(i));
   }
   Object* root;
   deserializer.DeserializePartial(isolate, &root);
   deserializer.FlushICacheForNewCodeObjects();
   ASSERT(root->IsSharedFunctionInfo());
   return root;
@@ skipping 15 matching lines @@
     SetHeaderValue(kReservationsOffset + i, cs->CurrentAllocationAddress(i));
   }
 }
 
 
 bool SerializedCodeData::IsSane() {
   return GetHeaderValue(kVersionHashOffset) == Version::Hash() &&
          PayloadLength() >= SharedFunctionInfo::kSize;
 }
 } }  // namespace v8::internal