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

src/serialize.cc

 // 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 1909 matching lines @@
   Object** limit = current + (size >> kPointerSizeLog2);
   while (current < limit) {
     DataType data = static_cast<DataType>(source_->Get());
     switch (data) {
       case SMI_SERIALIZATION:
         *current++ = Smi::FromInt(source_->GetInt() - kSmiBias);
         break;
       case RAW_DATA_SERIALIZATION: {
         int size = source_->GetInt();
         byte* raw_data_out = reinterpret_cast<byte*>(current);
-        for (int j = 0; j < size; j++) {
-          *raw_data_out++ = source_->Get();
-        }
-        current = reinterpret_cast<Object**>(raw_data_out);
+        source_->CopyRaw(raw_data_out, size);
+        current = reinterpret_cast<Object**>(raw_data_out + size);
         break;
       }
       case OBJECT_SERIALIZATION: {
         // Recurse to unpack an object that is forward-referenced from here.
         bool in_new_space = ReadObject(current);
         if (in_new_space && space != NEW_SPACE) {
           Heap::RecordWrite(address,
                             reinterpret_cast<Address>(current) - address);
         }
         current++;
@@ skipping 33 matching lines @@
         location_of_branch_data += Assembler::kCallTargetSize;
         current = reinterpret_cast<Object**>(location_of_branch_data);
         break;
         }
       case EXTERNAL_REFERENCE_SERIALIZATION: {
         int reference_id = source_->GetInt();
         Address address = external_reference_decoder_->Decode(reference_id);
         *current++ = reinterpret_cast<Object*>(address);
         break;
       }
+      case EXTERNAL_BRANCH_TARGET_SERIALIZATION: {
+        int reference_id = source_->GetInt();
+        Address address = external_reference_decoder_->Decode(reference_id);
+        Address location_of_branch_data = reinterpret_cast<Address>(current);
+        Assembler::set_external_target_at(location_of_branch_data, address);
+        location_of_branch_data += Assembler::kExternalTargetSize;
+        current = reinterpret_cast<Object**>(location_of_branch_data);
+        break;
+      }
       default:
         UNREACHABLE();
     }
   }
   ASSERT(current == limit);
   return space == NEW_SPACE;
 }
 
 
 void SnapshotByteSink::PutInt(uintptr_t integer, const char* description) {
@@ skipping 155 matching lines @@
 
   for (Address* current = start; current < end; current++) {
     sink_->Put(EXTERNAL_REFERENCE_SERIALIZATION, "External reference");
     int reference_id = serializer_->EncodeExternalReference(*current);
     sink_->PutInt(reference_id, "reference id");
   }
   bytes_processed_so_far_ += (end - start) * kPointerSize;
 }
 
 
+void Serializer2::ObjectSerializer::VisitRuntimeEntry(RelocInfo* rinfo) {
+  Address target_start = rinfo->target_address_address();
+  OutputRawData(target_start);
+  Address target = rinfo->target_address();
+  uint32_t encoding = serializer_->EncodeExternalReference(target);
+  CHECK(target == NULL ? encoding == 0 : encoding != 0);
+  sink_->Put(EXTERNAL_BRANCH_TARGET_SERIALIZATION, "External reference");
+  sink_->PutInt(encoding, "reference id");
+  bytes_processed_so_far_ += Assembler::kExternalTargetSize;
+}
+
+
 void Serializer2::ObjectSerializer::VisitCodeTarget(RelocInfo* rinfo) {
   ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
   Address target_start = rinfo->target_address_address();
   OutputRawData(target_start);
   Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
   serializer_->SerializeObject(target, CODE_TARGET_REPRESENTATION);
   bytes_processed_so_far_ += Assembler::kCallTargetSize;
 }
 
 
 void Serializer2::ObjectSerializer::OutputRawData(Address up_to) {
   Address object_start = object_->address();
   int up_to_offset = up_to - object_start;
   int skipped = up_to_offset - bytes_processed_so_far_;
   // This assert will fail if the reloc info gives us the target_address_address
   // locations in a non-ascending order.  Luckily that doesn't happen.
   ASSERT(skipped >= 0);
   if (skipped != 0) {
     sink_->Put(RAW_DATA_SERIALIZATION, "raw data");
     sink_->PutInt(skipped, "length");
     for (int i = 0; i < skipped; i++) {
       unsigned int data = object_start[bytes_processed_so_far_ + i];
       sink_->Put(data, "byte");
     }
+    bytes_processed_so_far_ += skipped;
   }
-  bytes_processed_so_far_ += skipped;
 }
 
 
 int Serializer2::SpaceOfObject(HeapObject* object) {
   for (int i = FIRST_SPACE; i <= LAST_SPACE; i++) {
     AllocationSpace s = static_cast<AllocationSpace>(i);
     if (Heap::InSpace(object, s)) {
       if (i == LO_SPACE) {
         if (object->IsCode()) {
           return kLargeCode;
@@ skipping 44 matching lines @@
       fullness_[space] = RoundUp(fullness_[space], Page::kPageSize);
     }
   }
   int allocation_address = fullness_[space];
   fullness_[space] = allocation_address + size;
   return allocation_address;
 }
 
 
 } }  // namespace v8::internal