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

src/snapshot/serializer.h

 // 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.
 
 #ifndef V8_SNAPSHOT_SERIALIZER_H_
 #define V8_SNAPSHOT_SERIALIZER_H_
 
 #include "src/isolate.h"
 #include "src/log.h"
 #include "src/objects.h"
@@ skipping 137 matching lines @@
     }
 
    private:
     static const int kMaxRecursionDepth = 32;
     Serializer* serializer_;
   };
 
   virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
                                WhereToPoint where_to_point, int skip) = 0;
 
+  void VisitPointers(Object** start, Object** end) override;
+
   void PutRoot(int index, HeapObject* object, HowToCode how, WhereToPoint where,
                int skip);
 
+  void PutSmi(Smi* smi);
+
   void PutBackReference(HeapObject* object, BackReference reference);
 
   // Emit alignment prefix if necessary, return required padding space in bytes.
   int PutAlignmentPrefix(HeapObject* object);
 
   // Returns true if the object was successfully serialized.
   bool SerializeKnownObject(HeapObject* obj, HowToCode how_to_code,
                             WhereToPoint where_to_point, int skip);
 
   inline void FlushSkip(int skip) {
     if (skip != 0) {
       sink_->Put(kSkip, "SkipFromSerializeObject");
       sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
     }
   }
 
   bool BackReferenceIsAlreadyAllocated(BackReference back_reference);
 
   // This will return the space for an object.
   BackReference AllocateLargeObject(int size);
   BackReference Allocate(AllocationSpace space, int size);
   int EncodeExternalReference(Address addr) {
     return external_reference_encoder_.Encode(addr);
   }
 
+  bool HasNotExceededFirstPageOfEachSpace();
+
   // GetInt reads 4 bytes at once, requiring padding at the end.
   void Pad();
 
-  // Some roots should not be serialized, because their actual value depends on
-  // absolute addresses and they are reset after deserialization, anyway.
-  bool ShouldBeSkipped(Object** current);
-
   // We may not need the code address map for logging for every instance
   // of the serializer.  Initialize it on demand.
   void InitializeCodeAddressMap();
 
   Code* CopyCode(Code* code);
 
   inline uint32_t max_chunk_size(int space) const {
     DCHECK_LE(0, space);
     DCHECK_LT(space, kNumberOfSpaces);
     return max_chunk_size_[space];
@@ skipping 17 matching lines @@
   RootIndexMap root_index_map_;
 
   int recursion_depth_;
 
   friend class Deserializer;
   friend class ObjectSerializer;
   friend class RecursionScope;
   friend class SnapshotData;
 
  private:
-  void VisitPointers(Object** start, Object** end) override;
-
   CodeAddressMap* code_address_map_;
   // Objects from the same space are put into chunks for bulk-allocation
   // when deserializing. We have to make sure that each chunk fits into a
   // page. So we track the chunk size in pending_chunk_ of a space, but
   // when it exceeds a page, we complete the current chunk and start a new one.
   uint32_t pending_chunk_[kNumberOfPreallocatedSpaces];
   List<uint32_t> completed_chunks_[kNumberOfPreallocatedSpaces];
   uint32_t max_chunk_size_[kNumberOfPreallocatedSpaces];
 
   // We map serialized large objects to indexes for back-referencing.
@@ skipping 70 matching lines @@
   SnapshotByteSink* sink_;
   int reference_representation_;
   int bytes_processed_so_far_;
   bool code_has_been_output_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SNAPSHOT_SERIALIZER_H_