[serializer] ensure that immortal immovable roots are correctly deserialized.

src/snapshot/serializer.cc

 // Copyright 2016 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/snapshot/serializer.h"
 
 #include "src/macro-assembler.h"
 #include "src/snapshot/natives.h"
 
 namespace v8 {
@@ skipping 78 matching lines @@
 
 void Serializer::SerializeDeferredObjects() {
   while (deferred_objects_.length() > 0) {
     HeapObject* obj = deferred_objects_.RemoveLast();
     ObjectSerializer obj_serializer(this, obj, sink_, kPlain, kStartOfObject);
     obj_serializer.SerializeDeferred();
   }
   sink_->Put(kSynchronize, "Finished with deferred objects");
 }
 
-bool Serializer::ShouldBeSkipped(Object** current) {
-  Object** roots = isolate()->heap()->roots_array_start();

[Michael Starzinger, 2016/03/17 12:27:29]

Woot! I love this, this was one of the last remaining places that references the
roots array directly IIRC. I think this enables one of my cleanups I had in mind
for a long time. Love it!

-  return current == &roots[Heap::kStoreBufferTopRootIndex] ||
-         current == &roots[Heap::kStackLimitRootIndex] ||
-         current == &roots[Heap::kRealStackLimitRootIndex];
-}
-
 void Serializer::VisitPointers(Object** start, Object** end) {
   for (Object** current = start; current < end; current++) {
     if ((*current)->IsSmi()) {
-      sink_->Put(kOnePointerRawData, "Smi");
-      for (int i = 0; i < kPointerSize; i++) {
-        sink_->Put(reinterpret_cast<byte*>(current)[i], "Byte");
-      }
+      PutSmi(Smi::cast(*current));
     } else {
       SerializeObject(HeapObject::cast(*current), kPlain, kStartOfObject, 0);
     }
   }
 }
 
 void Serializer::EncodeReservations(
     List<SerializedData::Reservation>* out) const {
   for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
     for (int j = 0; j < completed_chunks_[i].length(); j++) {
@@ skipping 110 matching lines @@
       sink_->Put(kRootArrayConstantsWithSkip + root_index, "RootConstant");
       sink_->PutInt(skip, "SkipInPutRoot");
     }
   } else {
     FlushSkip(skip);
     sink_->Put(kRootArray + how_to_code + where_to_point, "RootSerialization");
     sink_->PutInt(root_index, "root_index");
   }
 }
 
+void Serializer::PutSmi(Smi* smi) {
+  sink_->Put(kOnePointerRawData, "Smi");
+  byte* bytes = reinterpret_cast<byte*>(&smi);
+  for (int i = 0; i < kPointerSize; i++) sink_->Put(bytes[i], "Byte");
+}
+
 void Serializer::PutBackReference(HeapObject* object, BackReference reference) {
   DCHECK(BackReferenceIsAlreadyAllocated(reference));
   sink_->PutInt(reference.reference(), "BackRefValue");
   hot_objects_.Add(object);
 }
 
 int Serializer::PutAlignmentPrefix(HeapObject* object) {
   AllocationAlignment alignment = object->RequiredAlignment();
   if (alignment != kWordAligned) {
     DCHECK(1 <= alignment && alignment <= 3);
@@ skipping 48 matching lines @@
   code_address_map_ = new CodeAddressMap(isolate_);
 }
 
 Code* Serializer::CopyCode(Code* code) {
   code_buffer_.Rewind(0);  // Clear buffer without deleting backing store.
   int size = code->CodeSize();
   code_buffer_.AddAll(Vector<byte>(code->address(), size));
   return Code::cast(HeapObject::FromAddress(&code_buffer_.first()));
 }
 
+bool Serializer::HasNotExceededFirstPageOfEachSpace() {
+  for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
+    if (!completed_chunks_[i].is_empty()) return false;
+  }
+  return true;
+}
+
 void Serializer::ObjectSerializer::SerializePrologue(AllocationSpace space,
                                                      int size, Map* map) {
   if (serializer_->code_address_map_) {
     const char* code_name =
         serializer_->code_address_map_->Lookup(object_->address());
     LOG(serializer_->isolate_,
         CodeNameEvent(object_->address(), sink_->Position(), code_name));
     LOG(serializer_->isolate_,
         SnapshotPositionEvent(object_, sink_->Position()));
   }
@@ skipping 439 matching lines @@
   if (to_skip != 0 && return_skip == kIgnoringReturn) {
     sink_->Put(kSkip, "Skip");
     sink_->PutInt(to_skip, "SkipDistance");
     to_skip = 0;
   }
   return to_skip;
 }
 
 }  // namespace internal
 }  // namespace v8