Add a CHECK to make sure we don't accidentally serialize type feedback

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 1289 matching lines @@
       }
 
       default:
         UNREACHABLE();
     }
   }
   DCHECK_EQ(limit, current);
 }
 
 
-Serializer::Serializer(Isolate* isolate, SnapshotByteSink* sink)
+Serializer::Serializer(Isolate* isolate, SnapshotByteSink* sink,
+                       bool allow_type_feedback)
     : isolate_(isolate),
       sink_(sink),
       external_reference_encoder_(new ExternalReferenceEncoder(isolate)),
       root_index_map_(isolate),
       code_address_map_(NULL),
       large_objects_total_size_(0),
-      seen_large_objects_index_(0) {
+      seen_large_objects_index_(0),
+      allow_type_feedback_(allow_type_feedback) {
   // The serializer is meant to be used only to generate initial heap images
   // from a context in which there is only one isolate.
   for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
     pending_chunk_[i] = 0;
     max_chunk_size_[i] = static_cast<uint32_t>(
         MemoryAllocator::PageAreaSize(static_cast<AllocationSpace>(i)));
   }
 }
 
 
@@ skipping 433 matching lines @@
       // around this, external strings are serialized to look like ordinary
       // sequential strings.
       // The exception are native source code strings, since we can recreate
       // their resources. In that case we fall through and leave it to
       // VisitExternalOneByteString further down.
       SerializeExternalString();
       return;
     }
   }
 
+  if (object_->IsSharedFunctionInfo() && !serializer_->allow_type_feedback_) {
+    CHECK(SharedFunctionInfo::cast(object_)
+              ->feedback_vector()
+              ->CanBeSerialized());
+  }
+
   int size = object_->Size();
   Map* map = object_->map();
   SerializePrologue(Serializer::SpaceOfObject(object_), size, map);
 
   // Serialize the rest of the object.
   CHECK_EQ(0, bytes_processed_so_far_);
   bytes_processed_so_far_ = kPointerSize;
 
   object_->IterateBody(map->instance_type(), size, this);
   OutputRawData(object_->address() + size);
@@ skipping 696 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