Serializer: clear next link in weak cells.

src/snapshot/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 1833 matching lines @@
   // maybe left-over bytes that need to be padded.
   int padding_size = allocation_size - SeqString::kHeaderSize - content_size;
   DCHECK(0 <= padding_size && padding_size < kObjectAlignment);
   for (int i = 0; i < padding_size; i++) sink_->PutSection(0, "StringPadding");
 
   sink_->Put(kSkip, "SkipAfterString");
   sink_->PutInt(bytes_to_output, "SkipDistance");
 }
 
 
+// Clear and later restore the next link in the weak cell, if the object is one.
+class UnlinkWeakCellScope {
+ public:
+  explicit UnlinkWeakCellScope(HeapObject* object) : weak_cell_(NULL) {
+    if (object->IsWeakCell()) {
+      weak_cell_ = WeakCell::cast(object);
+      next_ = weak_cell_->next();
+      weak_cell_->clear_next(object->GetHeap());
+    }
+  }
+
+  ~UnlinkWeakCellScope() {
+    if (weak_cell_) weak_cell_->set_next(next_);

[ulan, 2015/06/24 11:11:19]

set_next(next_, UPDATE_WEAK_WRITE_BARRIER)

+  }
+
+ private:
+  WeakCell* weak_cell_;
+  Object* next_;
+};
+
+
 void Serializer::ObjectSerializer::Serialize() {
   if (FLAG_trace_serializer) {
     PrintF(" Encoding heap object: ");
     object_->ShortPrint();
     PrintF("\n");
   }
 
   // We cannot serialize typed array objects correctly.
   DCHECK(!object_->IsJSTypedArray());
 
@@ skipping 39 matching lines @@
 
   RecursionScope recursion(serializer_);
   // Objects that are immediately post processed during deserialization
   // cannot be deferred, since post processing requires the object content.
   if (recursion.ExceedsMaximum() && CanBeDeferred(object_)) {
     serializer_->QueueDeferredObject(object_);
     sink_->Put(kDeferred, "Deferring object content");
     return;
   }
 
+  UnlinkWeakCellScope unlink_weak_cell(object_);

[ulan, 2015/06/24 11:11:19]

Please add disallow allocation scope here or in UnlinkWeakCellScope.

+
   object_->IterateBody(map->instance_type(), size, this);
   OutputRawData(object_->address() + size);
 }
 
 
 void Serializer::ObjectSerializer::SerializeDeferred() {
   if (FLAG_trace_serializer) {
     PrintF(" Encoding deferred heap object: ");
     object_->ShortPrint();
     PrintF("\n");
   }
 
   int size = object_->Size();
   Map* map = object_->map();
   BackReference reference = serializer_->back_reference_map()->Lookup(object_);
 
   // Serialize the rest of the object.
   CHECK_EQ(0, bytes_processed_so_far_);
   bytes_processed_so_far_ = kPointerSize;
 
   sink_->Put(kNewObject + reference.space(), "deferred object");
   serializer_->PutBackReference(object_, reference);
   sink_->PutInt(size >> kPointerSizeLog2, "deferred object size");
 
+  UnlinkWeakCellScope unlink_weak_cell(object_);

[ulan, 2015/06/24 11:11:19]

Please add disallow allocation scope here or in UnlinkWeakCellScope.

+
   object_->IterateBody(map->instance_type(), size, this);
   OutputRawData(object_->address() + size);
 }
 
 
 void Serializer::ObjectSerializer::VisitPointers(Object** start,
                                                  Object** end) {
   Object** current = start;
   while (current < end) {
     while (current < end && (*current)->IsSmi()) current++;
@@ skipping 761 matching lines @@
   SerializedCodeData* scd = new SerializedCodeData(cached_data);
   SanityCheckResult r = scd->SanityCheck(isolate, source);
   if (r == CHECK_SUCCESS) return scd;
   cached_data->Reject();
   source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(r);
   delete scd;
   return NULL;
 }
 }  // namespace internal
 }  // namespace v8