Ensure double alignment when deserializing.

src/serialize.cc

Index: src/serialize.cc
diff --git a/src/serialize.cc b/src/serialize.cc
index c2dd338b7ec5c3151a4f9e7606a324f72d9aa8d2..b9d19ad0aa22fa0a2f7d0e8966588a7cb065281e 100644
--- a/src/serialize.cc
+++ b/src/serialize.cc
@@ -807,11 +807,21 @@ Object* Deserializer::ProcessBackRefInSerializedCode(Object* obj) {
 // 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) {
+void Deserializer::ReadObject(int space_number, Object** write_back,
+                              bool double_align) {
   int size = source_->GetInt() << kObjectAlignmentBits;
-  Address address = Allocate(space_number, size);
-  HeapObject* obj = HeapObject::FromAddress(address);
+  Address address;
+  HeapObject* obj;
+  if (double_align) {
+    DCHECK_NE(LO_SPACE, space_number);
+    address = Allocate(space_number, size + kPointerSize);

[rmcilroy, 2014/11/26 17:44:40]

You should only need to add kPointerSize if not a 64bit architecture (this is
what the Heap::AllocateXXX calls do).

[Yang, 2014/11/26 18:59:49]

I think this entire if-branch can be omitted for 64bit archs?

[rmcilroy, 2014/11/26 19:24:46]

agreed.

+    obj = isolate_->heap()->DoubleAlignForDeserialization(
+        HeapObject::FromAddress(address), size + kPointerSize);
+    address = obj->address();
+  } else {
+    address = Allocate(space_number, size);
+    obj = HeapObject::FromAddress(address);
+  }
   isolate_->heap()->OnAllocationEvent(obj, size);
   Object** current = reinterpret_cast<Object**>(address);
   Object** limit = current + (size >> kPointerSizeLog2);
@@ -894,6 +904,7 @@ void Deserializer::ReadData(Object** current, Object** limit, int source_space,
                                source_space != PROPERTY_CELL_SPACE &&
                                source_space != CODE_SPACE &&
                                source_space != OLD_DATA_SPACE);
+  bool double_align_next_object = false;
   while (current < limit) {
     int data = source_->Get();
     switch (data) {
@@ -911,13 +922,16 @@ void Deserializer::ReadData(Object** current, Object** limit, int source_space,
     int space_number = space_number_if_any == kAnyOldSpace                     \
                            ? (data & kSpaceMask)                               \
                            : space_number_if_any;                              \
+    DCHECK(!double_align_next_object || where == kNewObject);                  \
     if (where == kNewObject && how == kPlain && within == kStartOfObject) {    \
-      ReadObject(space_number, current);                                       \
+      ReadObject(space_number, current, double_align_next_object);             \
+      double_align_next_object = false;                                        \
       emit_write_barrier = (space_number == NEW_SPACE);                        \
     } else {                                                                   \
       Object* new_object = NULL; /* May not be a real Object pointer. */       \
       if (where == kNewObject) {                                               \
-        ReadObject(space_number, &new_object);                                 \
+        ReadObject(space_number, &new_object, double_align_next_object);       \
+        double_align_next_object = false;                                      \
       } else if (where == kRootArray) {                                        \
         int root_id = source_->GetInt();                                       \
         new_object = isolate->heap()->roots_array_start()[root_id];            \
@@ -1238,6 +1252,14 @@ void Deserializer::ReadData(Object** current, Object** limit, int source_space,
         break;
       }
 
+#ifndef V8_HOST_ARCH_64_BIT
+      case kDoubleAlignPrefix: {
+        DCHECK(!double_align_next_object);
+        double_align_next_object = true;
+        break;
+      }
+#endif
+
       case kSynchronize: {
         // If we get here then that indicates that you have a mismatch between
         // the number of GC roots when serializing and deserializing.
@@ -1549,6 +1571,14 @@ void PartialSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
 
 void Serializer::ObjectSerializer::SerializePrologue(AllocationSpace space,
                                                      int size, Map* map) {
+  int reserved_size = size;
+  // Objects on the large object space are always double-aligned.
+  if (space != LO_SPACE && object_->NeedsToEnsureDoubleAlignment()) {
+    sink_->Put(kDoubleAlignPrefix, "double align next object");
+    // Add wriggle room for double alignment padding.
+    reserved_size += kPointerSize;
+  }
+
   sink_->Put(kNewObject + reference_representation_ + space,
              "ObjectSerialization");
   sink_->PutInt(size >> kObjectAlignmentBits, "Size in words");
@@ -1572,7 +1602,7 @@ void Serializer::ObjectSerializer::SerializePrologue(AllocationSpace space,
     }
     back_reference = serializer_->AllocateLargeObject(size);
   } else {
-    back_reference = serializer_->Allocate(space, size);
+    back_reference = serializer_->Allocate(space, reserved_size);
   }
   serializer_->back_reference_map()->Add(object_, back_reference);
 
@@ -1918,7 +1948,7 @@ BackReference Serializer::AllocateLargeObject(int size) {
 
 
 BackReference Serializer::Allocate(AllocationSpace space, int size) {
-  CHECK(space >= 0 && space < kNumberOfPreallocatedSpaces);
+  DCHECK(space >= 0 && space < kNumberOfPreallocatedSpaces);
   DCHECK(size > 0 && size <= static_cast<int>(max_chunk_size(space)));
   uint32_t new_chunk_size = pending_chunk_[space] + size;
   if (new_chunk_size > max_chunk_size(space)) {