Fix missing write barrier in deserialization. Issue 1783.

src/serialize.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 677 matching lines @@
     external_reference_decoder_ = NULL;
   }
 }
 
 
 // This is called on the roots.  It is the driver of the deserialization
 // process.  It is also called on the body of each function.
 void Deserializer::VisitPointers(Object** start, Object** end) {
   // The space must be new space.  Any other space would cause ReadChunk to try
   // to update the remembered using NULL as the address.
-  ReadChunk(start, end, NEW_SPACE, NULL);
+  ReadChunk(NULL, start, end, NEW_SPACE, NULL);
 }
 
 
 // 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,
                               Space* space,
                               Object** write_back) {
   int size = source_->GetInt() << kObjectAlignmentBits;
   Address address = Allocate(space_number, space, size);
-  *write_back = HeapObject::FromAddress(address);
+  HeapObject* new_object = HeapObject::FromAddress(address);
+  *write_back = new_object;
   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);
+  ReadChunk(new_object, current, limit, space_number, address);
 #ifdef DEBUG
   bool is_codespace = (space == HEAP->code_space()) ||
       ((space == HEAP->lo_space()) && (space_number == kLargeCode));
   ASSERT(HeapObject::FromAddress(address)->IsCode() == is_codespace);
 #endif
 }
 
 
 // This macro is always used with a constant argument so it should all fold
 // away to almost nothing in the generated code.  It might be nicer to do this
@@ skipping 14 matching lines @@
     dest_space = isolate->heap()->cell_space();                                \
   } else {                                                                     \
     ASSERT(space_number >= LO_SPACE);                                          \
     dest_space = isolate->heap()->lo_space();                                  \
   }
 
 
 static const int kUnknownOffsetFromStart = -1;
 
 
-void Deserializer::ReadChunk(Object** current,
+void Deserializer::ReadChunk(HeapObject* host,
+                             Object** current,
                              Object** limit,
                              int source_space,
                              Address address) {
   Isolate* const isolate = isolate_;
   while (current < limit) {
     int data = source_->Get();
     switch (data) {
 #define CASE_STATEMENT(where, how, within, space_number)                       \
       case where + how + within + space_number:                                \
       ASSERT((where & ~kPointedToMask) == 0);                                  \
       ASSERT((how & ~kHowToCodeMask) == 0);                                    \
       ASSERT((within & ~kWhereToPointMask) == 0);                              \
       ASSERT((space_number & ~kSpaceMask) == 0);
 
 #define CASE_BODY(where, how, within, space_number_if_any, offset_from_start)  \
       {                                                                        \
         bool emit_write_barrier = false;                                       \
         bool current_was_incremented = false;                                  \
+        bool cell_was_written = false;                                         \
         int space_number =  space_number_if_any == kAnyOldSpace ?              \
                             (data & kSpaceMask) : space_number_if_any;         \
         if (where == kNewObject && how == kPlain && within == kStartOfObject) {\
           ASSIGN_DEST_SPACE(space_number)                                      \
           ReadObject(space_number, dest_space, current);                       \
           emit_write_barrier = (space_number == NEW_SPACE &&                   \
                                 source_space != NEW_SPACE &&                   \
                                 source_space != CELL_SPACE);                   \
         } else {                                                               \
           Object* new_object = NULL;  /* May not be a real Object pointer. */  \
           if (where == kNewObject) {                                           \
             ASSIGN_DEST_SPACE(space_number)                                    \
             ReadObject(space_number, dest_space, &new_object);                 \
-          } else if (where == kRootArray) {                                    \
-            int root_id = source_->GetInt();                                   \
-            new_object = isolate->heap()->roots_array_start()[root_id];        \
-          } else if (where == kPartialSnapshotCache) {                         \
-            int cache_index = source_->GetInt();                               \
-            new_object = isolate->serialize_partial_snapshot_cache()           \
-                [cache_index];                                                 \
+          } else if (where == kRootArray || where == kPartialSnapshotCache) {  \
+            if (where == kRootArray) {                                         \
+              int root_id = source_->GetInt();                                 \
+              new_object = isolate->heap()->roots_array_start()[root_id];      \
+            } else {                                                           \
+              ASSERT(where == kPartialSnapshotCache);                          \
+              int cache_index = source_->GetInt();                             \
+              new_object = isolate->serialize_partial_snapshot_cache()         \
+                  [cache_index];                                               \
+            }                                                                  \
+            if (how != kFromCode) {                                            \
+              cell_was_written = true;                                         \
+              if (within == kFirstInstruction) {                               \
+                Code* new_code_object = reinterpret_cast<Code*>(new_object);   \
+                new_object = reinterpret_cast<Object*>(                        \
+                    new_code_object->instruction_start());                     \
+                *current = new_object;                                         \
+                isolate->heap()->incremental_marking()->RecordWriteOfCodeEntry(\
+                  reinterpret_cast<JSFunction*>(host),                         \
+                  current,                                                     \
+                  new_code_object);                                            \
+              } else {                                                         \
+                ASSERT(within == kStartOfObject);                              \
+                *current = new_object;                                         \
+                isolate->heap()->incremental_marking()->RecordWrite(           \
+                  host, current, new_object);                                  \
+              }                                                                \
+            }                                                                  \
           } else if (where == kExternalReference) {                            \
             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 &&                 \
                                   source_space != NEW_SPACE &&                 \
                                   source_space != CELL_SPACE);                 \
             new_object = GetAddressFromEnd(data & kSpaceMask);                 \
@@ skipping 19 matching lines @@
             Address location_of_branch_data =                                  \
                 reinterpret_cast<Address>(current);                            \
             Assembler::set_target_at(location_of_branch_data,                  \
                                      reinterpret_cast<Address>(new_object));   \
             if (within == kFirstInstruction) {                                 \
               location_of_branch_data += Assembler::kCallTargetSize;           \
               current = reinterpret_cast<Object**>(location_of_branch_data);   \
               current_was_incremented = true;                                  \
             }                                                                  \
           } else {                                                             \
-            *current = new_object;                                             \
+            if (!cell_was_written) *current = new_object;                      \
           }                                                                    \
         }                                                                      \
         if (emit_write_barrier) {                                              \
           isolate->heap()->RecordWrite(address, static_cast<int>(              \
               reinterpret_cast<Address>(current) - address));                  \
         }                                                                      \
         if (!current_was_incremented) {                                        \
           current++;   /* Increment current if it wasn't done above. */        \
         }                                                                      \
         break;                                                                 \
@@ skipping 83 matching lines @@
       }
 
       case kRepeat: {
         int repeats = source_->GetInt();
         Object* object = current[-1];
         for (int i = 0; i < repeats; i++) current[i] = object;
         current += repeats;
         break;
       }
 
+      STATIC_ASSERT(kRootArrayNumberOfConstantEncodings ==
+                    Heap::kOldSpaceRoots);
       STATIC_ASSERT(kMaxRepeats == 12);
       FOUR_CASES(kConstantRepeat)
       FOUR_CASES(kConstantRepeat + 4)
       FOUR_CASES(kConstantRepeat + 8) {
         int repeats = RepeatsForCode(data);
         Object* object = current[-1];
         for (int i = 0; i < repeats; i++) current[i] = object;
         current += repeats;
         break;
       }
@@ skipping 473 matching lines @@
 
 
 void Serializer::ObjectSerializer::VisitPointers(Object** start,
                                                  Object** end) {
   Object** current = start;
   while (current < end) {
     while (current < end && (*current)->IsSmi()) current++;
     if (current < end) OutputRawData(reinterpret_cast<Address>(current));
 
     while (current < end && !(*current)->IsSmi()) {
+      HeapObject* current_contents = HeapObject::cast(*current);
+      int root_index = serializer_->RootIndex(current_contents);
+      // Repeats are not subject to the write barrier so there are only some
+      // objects that can be used in a repeat encoding.  These are the early
+      // ones in the root array that are on the first page and never in new
+      // space.
       if (current != start &&
-          current[0] == current[-1] &&
-          !HEAP->InNewSpace(*current)) {
+          root_index != kInvalidRootIndex &&
+          root_index < kRootArrayNumberOfConstantEncodings &&
+          current_contents == current[-1] &&
+          !HEAP->InNewSpace(current_contents)) {
         int repeat_count = 1;
-        while (current < end - 1 && current[repeat_count] == current[0]) {
+        while (current < end - 1 && current[repeat_count] == current_contents) {
           repeat_count++;
         }
         current += repeat_count;
         bytes_processed_so_far_ += repeat_count * kPointerSize;
         if (repeat_count > kMaxRepeats) {
           sink_->Put(kRepeat, "SerializeRepeats");
           sink_->PutInt(repeat_count, "SerializeRepeats");
         } else {
           sink_->Put(CodeForRepeats(repeat_count), "SerializeRepeats");
         }
       } else {
-        serializer_->SerializeObject(*current, kPlain, kStartOfObject);
+        serializer_->SerializeObject(current_contents, kPlain, kStartOfObject);
         bytes_processed_so_far_ += kPointerSize;
         current++;
       }
     }
   }
 }
 
 
 void Serializer::ObjectSerializer::VisitExternalReferences(Address* start,
                                                            Address* end) {
@@ skipping 166 matching lines @@
       fullness_[space] = RoundUp(fullness_[space], Page::kPageSize);
     }
   }
   int allocation_address = fullness_[space];
   fullness_[space] = allocation_address + size;
   return allocation_address;
 }
 
 
 } }  // namespace v8::internal