Introduce a switch for the new snapshot code and switch...

src/serialize.h

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 345 matching lines @@
   SnapshotByteSource(const byte* array, int length)
     : data_(array), length_(length), position_(0) { }
 
   bool HasMore() { return position_ < length_; }
 
   int Get() {
     ASSERT(position_ < length_);
     return data_[position_++];
   }
 
+  void CopyRaw(byte* to, int number_of_bytes) {
+    memcpy(to, data_ + position_, number_of_bytes);
+    position_ += number_of_bytes;
+  }
+
   int GetInt() {
     // A little unwind to catch the really small ints.
     int snapshot_byte = Get();
     if ((snapshot_byte & 0x80) == 0) {
       return snapshot_byte;
     }
     uintptr_t accumulator = (snapshot_byte & 0x7f) << 7;
     while (true) {
       snapshot_byte = Get();
       if ((snapshot_byte & 0x80) == 0) {
@@ skipping 22 matching lines @@
 class SerDes: public GenericDeserializer {
  protected:
   enum DataType {
     SMI_SERIALIZATION,
     RAW_DATA_SERIALIZATION,
     OBJECT_SERIALIZATION,
     CODE_OBJECT_SERIALIZATION,
     BACKREF_SERIALIZATION,
     CODE_BACKREF_SERIALIZATION,
     EXTERNAL_REFERENCE_SERIALIZATION,
+    EXTERNAL_BRANCH_TARGET_SERIALIZATION,
     SYNCHRONIZE
   };
   // Our Smi encoding is much more efficient for small positive integers than it
   // is for negative numbers so we add a bias before encoding and subtract it
   // after encoding so that popular small negative Smis are efficiently encoded.
   static const int kSmiBias = 16;
   static const int kLargeData = LAST_SPACE;
   static const int kLargeCode = kLargeData + 1;
   static const int kLargeFixedArray = kLargeCode + 1;
   static const int kNumberOfSpaces = kLargeFixedArray + 1;
@@ skipping 96 matching lines @@
                      ReferenceRepresentation representation)
       : serializer_(serializer),
         object_(HeapObject::cast(o)),
         sink_(sink),
         reference_representation_(representation),
         bytes_processed_so_far_(0) { }
     void Serialize();
     void VisitPointers(Object** start, Object** end);
     void VisitExternalReferences(Address* start, Address* end);
     void VisitCodeTarget(RelocInfo* target);
+    void VisitRuntimeEntry(RelocInfo* reloc);
 
    private:
     void OutputRawData(Address up_to);
 
     Serializer2* serializer_;
     HeapObject* object_;
     SnapshotByteSink* sink_;
     ReferenceRepresentation reference_representation_;
     int bytes_processed_so_far_;
   };
@@ skipping 29 matching lines @@
 
   friend class ObjectSerializer;
   friend class Deserializer2;
 
   DISALLOW_COPY_AND_ASSIGN(Serializer2);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_