Fix crash in V8 during serializing objects requiring alignment.

src/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 1639 matching lines @@
     sink_->Put(kNewObject + reference_representation_ + space,
                "NewLargeObject");
     sink_->PutInt(size >> kObjectAlignmentBits, "ObjectSizeInWords");
     if (object_->IsCode()) {
       sink_->Put(EXECUTABLE, "executable large object");
     } else {
       sink_->Put(NOT_EXECUTABLE, "not executable large object");
     }
     back_reference = serializer_->AllocateLargeObject(size);
   } else {
+    bool needs_double_align = false;
     if (object_->NeedsToEnsureDoubleAlignment()) {
       // Add wriggle room for double alignment padding.
       back_reference = serializer_->Allocate(space, size + kPointerSize);
-      sink_->PutInt(kDoubleAlignmentSentinel, "DoubleAlignSentinel");
+      needs_double_align = true;
     } else {
       back_reference = serializer_->Allocate(space, size);
     }
     sink_->Put(kNewObject + reference_representation_ + space, "NewObject");

[Yang, 2014/12/10 20:47:58]

How about we simply put this line (outputting the new object) before the if-else
clause?

[Slava Chigrin, 2014/12/11 09:16:40]

I am afraid this will not work - Serializer::Allocate may output kNextChunk to
the sink, so resulting binary stream will differ. It will be

kNewObject, [kNewChunk, chunk_space], [kDoubleAlignmentSentinel], object_size, 

whereas correct order is 
[kNewChunk, chunk_space], kNewObject, [kDoubleAlignmentSentinel], object_size

On 2014/12/10 20:47:58, Yang wrote:

+    if (needs_double_align)

[Slava Chigrin, 2014/12/10 18:13:58]

Deserializer::ReadObject expects DoubleAlignmentSentinel be just before size
field, not before "NewObject" tag.

[Yang, 2014/12/10 20:45:48]

Thanks for catching this! I guess I got confused when refactoring a couple of
things when implementing this.

+      sink_->PutInt(kDoubleAlignmentSentinel, "DoubleAlignSentinel");
     int encoded_size = size >> kObjectAlignmentBits;
     DCHECK_NE(kDoubleAlignmentSentinel, encoded_size);
     sink_->PutInt(encoded_size, "ObjectSizeInWords");
   }
 
   // Mark this object as already serialized.
   serializer_->back_reference_map()->Add(object_, back_reference);
 
   // Serialize the map (first word of the object).
   serializer_->SerializeObject(map, kPlain, kStartOfObject, 0);
@@ skipping 798 matching lines @@
   return GetHeaderValue(kNumInternalizedStringsOffset);
 }
 
 Vector<const uint32_t> SerializedCodeData::CodeStubKeys() const {
   int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
   const byte* start = data_ + kHeaderSize + reservations_size;
   return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
                                 GetHeaderValue(kNumCodeStubKeysOffset));
 }
 } }  // namespace v8::internal