src/3rdparty/v8/src/serialize.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include "v8.h"
  29
  30 #include "accessors.h"
  31 #include "api.h"
  32 #include "bootstrapper.h"
  33 #include "execution.h"
  34 #include "global-handles.h"
  35 #include "ic-inl.h"
  36 #include "natives.h"
  37 #include "platform.h"
  38 #include "runtime.h"
  39 #include "serialize.h"
  40 #include "stub-cache.h"
  41 #include "v8threads.h"
  42
  43 namespace v8 {
  44 namespace internal {
  45
  46
  47 // -----------------------------------------------------------------------------
  48 // Coding of external references.
  49
  50 // The encoding of an external reference. The type is in the high word.
  51 // The id is in the low word.
  52 static uint32_t EncodeExternal(TypeCode type, uint16_t id) {
  53   return static_cast<uint32_t>(type) << 16 | id;
  54 }
  55
  56
  57 static int* GetInternalPointer(StatsCounter* counter) {
  58   // All counters refer to dummy_counter, if deserializing happens without
  59   // setting up counters.
  60   static int dummy_counter = 0;
  61   return counter->Enabled() ? counter->GetInternalPointer() : &dummy_counter;
  62 }
  63
  64
  65 ExternalReferenceTable* ExternalReferenceTable::instance(Isolate* isolate) {
  66   ExternalReferenceTable* external_reference_table =
  67       isolate->external_reference_table();
  68   if (external_reference_table == NULL) {
  69     external_reference_table = new ExternalReferenceTable(isolate);
  70     isolate->set_external_reference_table(external_reference_table);
  71   }
  72   return external_reference_table;
  73 }
  74
  75
  76 void ExternalReferenceTable::AddFromId(TypeCode type,
  77                                        uint16_t id,
  78                                        const char* name,
  79                                        Isolate* isolate) {
  80   Address address;
  81   switch (type) {
  82     case C_BUILTIN: {
  83       ExternalReference ref(static_cast<Builtins::CFunctionId>(id), isolate);
  84       address = ref.address();
  85       break;
  86     }
  87     case BUILTIN: {
  88       ExternalReference ref(static_cast<Builtins::Name>(id), isolate);
  89       address = ref.address();
  90       break;
  91     }
  92     case RUNTIME_FUNCTION: {
  93       ExternalReference ref(static_cast<Runtime::FunctionId>(id), isolate);
  94       address = ref.address();
  95       break;
  96     }
  97     case IC_UTILITY: {
  98       ExternalReference ref(IC_Utility(static_cast<IC::UtilityId>(id)),
  99                             isolate);
 100       address = ref.address();
 101       break;
 102     }
 103     default:
 104       UNREACHABLE();
 105       return;
 106   }
 107   Add(address, type, id, name);
 108 }
 109
 110
 111 void ExternalReferenceTable::Add(Address address,
 112                                  TypeCode type,
 113                                  uint16_t id,
 114                                  const char* name) {
 115   ASSERT_NE(NULL, address);
 116   ExternalReferenceEntry entry;
 117   entry.address = address;
 118   entry.code = EncodeExternal(type, id);
 119   entry.name = name;
 120   ASSERT_NE(0, entry.code);
 121   refs_.Add(entry);
 122   if (id > max_id_[type]) max_id_[type] = id;
 123 }
 124
 125
 126 void ExternalReferenceTable::PopulateTable(Isolate* isolate) {
 127   for (int type_code = 0; type_code < kTypeCodeCount; type_code++) {
 128     max_id_[type_code] = 0;
 129   }
 130
 131   // The following populates all of the different type of external references
 132   // into the ExternalReferenceTable.
 133   //
 134   // NOTE: This function was originally 100k of code.  It has since been
 135   // rewritten to be mostly table driven, as the callback macro style tends to
 136   // very easily cause code bloat.  Please be careful in the future when adding
 137   // new references.
 138
 139   struct RefTableEntry {
 140     TypeCode type;
 141     uint16_t id;
 142     const char* name;
 143   };
 144
 145   static const RefTableEntry ref_table[] = {
 146   // Builtins
 147 #define DEF_ENTRY_C(name, ignored) \
 148   { C_BUILTIN, \
 149     Builtins::c_##name, \
 150     "Builtins::" #name },
 151
 152   BUILTIN_LIST_C(DEF_ENTRY_C)
 153 #undef DEF_ENTRY_C
 154
 155 #define DEF_ENTRY_C(name, ignored) \
 156   { BUILTIN, \
 157     Builtins::k##name, \
 158     "Builtins::" #name },
 159 #define DEF_ENTRY_A(name, kind, state, extra) DEF_ENTRY_C(name, ignored)
 160
 161   BUILTIN_LIST_C(DEF_ENTRY_C)
 162   BUILTIN_LIST_A(DEF_ENTRY_A)
 163   BUILTIN_LIST_DEBUG_A(DEF_ENTRY_A)
 164 #undef DEF_ENTRY_C
 165 #undef DEF_ENTRY_A
 166
 167   // Runtime functions
 168 #define RUNTIME_ENTRY(name, nargs, ressize) \
 169   { RUNTIME_FUNCTION, \
 170     Runtime::k##name, \
 171     "Runtime::" #name },
 172
 173   RUNTIME_FUNCTION_LIST(RUNTIME_ENTRY)
 174 #undef RUNTIME_ENTRY
 175
 176   // IC utilities
 177 #define IC_ENTRY(name) \
 178   { IC_UTILITY, \
 179     IC::k##name, \
 180     "IC::" #name },
 181
 182   IC_UTIL_LIST(IC_ENTRY)
 183 #undef IC_ENTRY
 184   };  // end of ref_table[].
 185
 186   for (size_t i = 0; i < ARRAY_SIZE(ref_table); ++i) {
 187     AddFromId(ref_table[i].type,
 188               ref_table[i].id,
 189               ref_table[i].name,
 190               isolate);
 191   }
 192
 193 #ifdef ENABLE_DEBUGGER_SUPPORT
 194   // Debug addresses
 195   Add(Debug_Address(Debug::k_after_break_target_address).address(isolate),
 196       DEBUG_ADDRESS,
 197       Debug::k_after_break_target_address << kDebugIdShift,
 198       "Debug::after_break_target_address()");
 199   Add(Debug_Address(Debug::k_debug_break_slot_address).address(isolate),
 200       DEBUG_ADDRESS,
 201       Debug::k_debug_break_slot_address << kDebugIdShift,
 202       "Debug::debug_break_slot_address()");
 203   Add(Debug_Address(Debug::k_debug_break_return_address).address(isolate),
 204       DEBUG_ADDRESS,
 205       Debug::k_debug_break_return_address << kDebugIdShift,
 206       "Debug::debug_break_return_address()");
 207   Add(Debug_Address(Debug::k_restarter_frame_function_pointer).address(isolate),
 208       DEBUG_ADDRESS,
 209       Debug::k_restarter_frame_function_pointer << kDebugIdShift,
 210       "Debug::restarter_frame_function_pointer_address()");
 211 #endif
 212
 213   // Stat counters
 214   struct StatsRefTableEntry {
 215     StatsCounter* (Counters::*counter)();
 216     uint16_t id;
 217     const char* name;
 218   };
 219
 220   const StatsRefTableEntry stats_ref_table[] = {
 221 #define COUNTER_ENTRY(name, caption) \
 222   { &Counters::name,    \
 223     Counters::k_##name, \
 224     "Counters::" #name },
 225
 226   STATS_COUNTER_LIST_1(COUNTER_ENTRY)
 227   STATS_COUNTER_LIST_2(COUNTER_ENTRY)
 228 #undef COUNTER_ENTRY
 229   };  // end of stats_ref_table[].
 230
 231   Counters* counters = isolate->counters();
 232   for (size_t i = 0; i < ARRAY_SIZE(stats_ref_table); ++i) {
 233     Add(reinterpret_cast<Address>(GetInternalPointer(
 234             (counters->*(stats_ref_table[i].counter))())),
 235         STATS_COUNTER,
 236         stats_ref_table[i].id,
 237         stats_ref_table[i].name);
 238   }
 239
 240   // Top addresses
 241
 242   const char* AddressNames[] = {
 243 #define BUILD_NAME_LITERAL(CamelName, hacker_name)      \
 244     "Isolate::" #hacker_name "_address",
 245     FOR_EACH_ISOLATE_ADDRESS_NAME(BUILD_NAME_LITERAL)
 246     NULL
 247 #undef BUILD_NAME_LITERAL
 248   };
 249
 250   for (uint16_t i = 0; i < Isolate::kIsolateAddressCount; ++i) {
 251     Add(isolate->get_address_from_id((Isolate::AddressId)i),
 252         TOP_ADDRESS, i, AddressNames[i]);
 253   }
 254
 255   // Accessors
 256 #define ACCESSOR_DESCRIPTOR_DECLARATION(name) \
 257   Add((Address)&Accessors::name, \
 258       ACCESSOR, \
 259       Accessors::k##name, \
 260       "Accessors::" #name);
 261
 262   ACCESSOR_DESCRIPTOR_LIST(ACCESSOR_DESCRIPTOR_DECLARATION)
 263 #undef ACCESSOR_DESCRIPTOR_DECLARATION
 264
 265   StubCache* stub_cache = isolate->stub_cache();
 266
 267   // Stub cache tables
 268   Add(stub_cache->key_reference(StubCache::kPrimary).address(),
 269       STUB_CACHE_TABLE,
 270       1,
 271       "StubCache::primary_->key");
 272   Add(stub_cache->value_reference(StubCache::kPrimary).address(),
 273       STUB_CACHE_TABLE,
 274       2,
 275       "StubCache::primary_->value");
 276   Add(stub_cache->map_reference(StubCache::kPrimary).address(),
 277       STUB_CACHE_TABLE,
 278       3,
 279       "StubCache::primary_->map");
 280   Add(stub_cache->key_reference(StubCache::kSecondary).address(),
 281       STUB_CACHE_TABLE,
 282       4,
 283       "StubCache::secondary_->key");
 284   Add(stub_cache->value_reference(StubCache::kSecondary).address(),
 285       STUB_CACHE_TABLE,
 286       5,
 287       "StubCache::secondary_->value");
 288   Add(stub_cache->map_reference(StubCache::kSecondary).address(),
 289       STUB_CACHE_TABLE,
 290       6,
 291       "StubCache::secondary_->map");
 292
 293   // Runtime entries
 294   Add(ExternalReference::perform_gc_function(isolate).address(),
 295       RUNTIME_ENTRY,
 296       1,
 297       "Runtime::PerformGC");
 298   Add(ExternalReference::fill_heap_number_with_random_function(
 299           isolate).address(),
 300       RUNTIME_ENTRY,
 301       2,
 302       "V8::FillHeapNumberWithRandom");
 303   Add(ExternalReference::random_uint32_function(isolate).address(),
 304       RUNTIME_ENTRY,
 305       3,
 306       "V8::Random");
 307   Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
 308       RUNTIME_ENTRY,
 309       4,
 310       "HandleScope::DeleteExtensions");
 311   Add(ExternalReference::
 312           incremental_marking_record_write_function(isolate).address(),
 313       RUNTIME_ENTRY,
 314       5,
 315       "IncrementalMarking::RecordWrite");
 316   Add(ExternalReference::store_buffer_overflow_function(isolate).address(),
 317       RUNTIME_ENTRY,
 318       6,
 319       "StoreBuffer::StoreBufferOverflow");
 320   Add(ExternalReference::
 321           incremental_evacuation_record_write_function(isolate).address(),
 322       RUNTIME_ENTRY,
 323       7,
 324       "IncrementalMarking::RecordWrite");
 325
 326
 327
 328   // Miscellaneous
 329   Add(ExternalReference::roots_array_start(isolate).address(),
 330       UNCLASSIFIED,
 331       3,
 332       "Heap::roots_array_start()");
 333   Add(ExternalReference::address_of_stack_limit(isolate).address(),
 334       UNCLASSIFIED,
 335       4,
 336       "StackGuard::address_of_jslimit()");
 337   Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
 338       UNCLASSIFIED,
 339       5,
 340       "StackGuard::address_of_real_jslimit()");
 341 #ifndef V8_INTERPRETED_REGEXP
 342   Add(ExternalReference::address_of_regexp_stack_limit(isolate).address(),
 343       UNCLASSIFIED,
 344       6,
 345       "RegExpStack::limit_address()");
 346   Add(ExternalReference::address_of_regexp_stack_memory_address(
 347           isolate).address(),
 348       UNCLASSIFIED,
 349       7,
 350       "RegExpStack::memory_address()");
 351   Add(ExternalReference::address_of_regexp_stack_memory_size(isolate).address(),
 352       UNCLASSIFIED,
 353       8,
 354       "RegExpStack::memory_size()");
 355   Add(ExternalReference::address_of_static_offsets_vector(isolate).address(),
 356       UNCLASSIFIED,
 357       9,
 358       "OffsetsVector::static_offsets_vector");
 359 #endif  // V8_INTERPRETED_REGEXP
 360   Add(ExternalReference::new_space_start(isolate).address(),
 361       UNCLASSIFIED,
 362       10,
 363       "Heap::NewSpaceStart()");
 364   Add(ExternalReference::new_space_mask(isolate).address(),
 365       UNCLASSIFIED,
 366       11,
 367       "Heap::NewSpaceMask()");
 368   Add(ExternalReference::heap_always_allocate_scope_depth(isolate).address(),
 369       UNCLASSIFIED,
 370       12,
 371       "Heap::always_allocate_scope_depth()");
 372   Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
 373       UNCLASSIFIED,
 374       14,
 375       "Heap::NewSpaceAllocationLimitAddress()");
 376   Add(ExternalReference::new_space_allocation_top_address(isolate).address(),
 377       UNCLASSIFIED,
 378       15,
 379       "Heap::NewSpaceAllocationTopAddress()");
 380 #ifdef ENABLE_DEBUGGER_SUPPORT
 381   Add(ExternalReference::debug_break(isolate).address(),
 382       UNCLASSIFIED,
 383       16,
 384       "Debug::Break()");
 385   Add(ExternalReference::debug_step_in_fp_address(isolate).address(),
 386       UNCLASSIFIED,
 387       17,
 388       "Debug::step_in_fp_addr()");
 389 #endif
 390   Add(ExternalReference::double_fp_operation(Token::ADD, isolate).address(),
 391       UNCLASSIFIED,
 392       18,
 393       "add_two_doubles");
 394   Add(ExternalReference::double_fp_operation(Token::SUB, isolate).address(),
 395       UNCLASSIFIED,
 396       19,
 397       "sub_two_doubles");
 398   Add(ExternalReference::double_fp_operation(Token::MUL, isolate).address(),
 399       UNCLASSIFIED,
 400       20,
 401       "mul_two_doubles");
 402   Add(ExternalReference::double_fp_operation(Token::DIV, isolate).address(),
 403       UNCLASSIFIED,
 404       21,
 405       "div_two_doubles");
 406   Add(ExternalReference::double_fp_operation(Token::MOD, isolate).address(),
 407       UNCLASSIFIED,
 408       22,
 409       "mod_two_doubles");
 410   Add(ExternalReference::compare_doubles(isolate).address(),
 411       UNCLASSIFIED,
 412       23,
 413       "compare_doubles");
 414 #ifndef V8_INTERPRETED_REGEXP
 415   Add(ExternalReference::re_case_insensitive_compare_uc16(isolate).address(),
 416       UNCLASSIFIED,
 417       24,
 418       "NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16()");
 419   Add(ExternalReference::re_check_stack_guard_state(isolate).address(),
 420       UNCLASSIFIED,
 421       25,
 422       "RegExpMacroAssembler*::CheckStackGuardState()");
 423   Add(ExternalReference::re_grow_stack(isolate).address(),
 424       UNCLASSIFIED,
 425       26,
 426       "NativeRegExpMacroAssembler::GrowStack()");
 427   Add(ExternalReference::re_word_character_map().address(),
 428       UNCLASSIFIED,
 429       27,
 430       "NativeRegExpMacroAssembler::word_character_map");
 431 #endif  // V8_INTERPRETED_REGEXP
 432   // Keyed lookup cache.
 433   Add(ExternalReference::keyed_lookup_cache_keys(isolate).address(),
 434       UNCLASSIFIED,
 435       28,
 436       "KeyedLookupCache::keys()");
 437   Add(ExternalReference::keyed_lookup_cache_field_offsets(isolate).address(),
 438       UNCLASSIFIED,
 439       29,
 440       "KeyedLookupCache::field_offsets()");
 441   Add(ExternalReference::transcendental_cache_array_address(isolate).address(),
 442       UNCLASSIFIED,
 443       30,
 444       "TranscendentalCache::caches()");
 445   Add(ExternalReference::handle_scope_next_address().address(),
 446       UNCLASSIFIED,
 447       31,
 448       "HandleScope::next");
 449   Add(ExternalReference::handle_scope_limit_address().address(),
 450       UNCLASSIFIED,
 451       32,
 452       "HandleScope::limit");
 453   Add(ExternalReference::handle_scope_level_address().address(),
 454       UNCLASSIFIED,
 455       33,
 456       "HandleScope::level");
 457   Add(ExternalReference::new_deoptimizer_function(isolate).address(),
 458       UNCLASSIFIED,
 459       34,
 460       "Deoptimizer::New()");
 461   Add(ExternalReference::compute_output_frames_function(isolate).address(),
 462       UNCLASSIFIED,
 463       35,
 464       "Deoptimizer::ComputeOutputFrames()");
 465   Add(ExternalReference::address_of_min_int().address(),
 466       UNCLASSIFIED,
 467       36,
 468       "LDoubleConstant::min_int");
 469   Add(ExternalReference::address_of_one_half().address(),
 470       UNCLASSIFIED,
 471       37,
 472       "LDoubleConstant::one_half");
 473   Add(ExternalReference::isolate_address().address(),
 474       UNCLASSIFIED,
 475       38,
 476       "isolate");
 477   Add(ExternalReference::address_of_minus_zero().address(),
 478       UNCLASSIFIED,
 479       39,
 480       "LDoubleConstant::minus_zero");
 481   Add(ExternalReference::address_of_negative_infinity().address(),
 482       UNCLASSIFIED,
 483       40,
 484       "LDoubleConstant::negative_infinity");
 485   Add(ExternalReference::power_double_double_function(isolate).address(),
 486       UNCLASSIFIED,
 487       41,
 488       "power_double_double_function");
 489   Add(ExternalReference::power_double_int_function(isolate).address(),
 490       UNCLASSIFIED,
 491       42,
 492       "power_double_int_function");
 493   Add(ExternalReference::store_buffer_top(isolate).address(),
 494       UNCLASSIFIED,
 495       43,
 496       "store_buffer_top");
 497   Add(ExternalReference::address_of_canonical_non_hole_nan().address(),
 498       UNCLASSIFIED,
 499       44,
 500       "canonical_nan");
 501   Add(ExternalReference::address_of_the_hole_nan().address(),
 502       UNCLASSIFIED,
 503       45,
 504       "the_hole_nan");
 505   Add(ExternalReference::get_date_field_function(isolate).address(),
 506       UNCLASSIFIED,
 507       46,
 508       "JSDate::GetField");
 509   Add(ExternalReference::date_cache_stamp(isolate).address(),
 510       UNCLASSIFIED,
 511       47,
 512       "date_cache_stamp");
 513 }
 514
 515
 516 ExternalReferenceEncoder::ExternalReferenceEncoder()
 517     : encodings_(Match),
 518       isolate_(Isolate::Current()) {
 519   ExternalReferenceTable* external_references =
 520       ExternalReferenceTable::instance(isolate_);
 521   for (int i = 0; i < external_references->size(); ++i) {
 522     Put(external_references->address(i), i);
 523   }
 524 }
 525
 526
 527 uint32_t ExternalReferenceEncoder::Encode(Address key) const {
 528   int index = IndexOf(key);
 529   ASSERT(key == NULL || index >= 0);
 530   return index >=0 ?
 531          ExternalReferenceTable::instance(isolate_)->code(index) : 0;
 532 }
 533
 534
 535 const char* ExternalReferenceEncoder::NameOfAddress(Address key) const {
 536   int index = IndexOf(key);
 537   return index >= 0 ?
 538       ExternalReferenceTable::instance(isolate_)->name(index) : NULL;
 539 }
 540
 541
 542 int ExternalReferenceEncoder::IndexOf(Address key) const {
 543   if (key == NULL) return -1;
 544   HashMap::Entry* entry =
 545       const_cast<HashMap&>(encodings_).Lookup(key, Hash(key), false);
 546   return entry == NULL
 547       ? -1
 548       : static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
 549 }
 550
 551
 552 void ExternalReferenceEncoder::Put(Address key, int index) {
 553   HashMap::Entry* entry = encodings_.Lookup(key, Hash(key), true);
 554   entry->value = reinterpret_cast<void*>(index);
 555 }
 556
 557
 558 ExternalReferenceDecoder::ExternalReferenceDecoder()
 559     : encodings_(NewArray<Address*>(kTypeCodeCount)),
 560       isolate_(Isolate::Current()) {
 561   ExternalReferenceTable* external_references =
 562       ExternalReferenceTable::instance(isolate_);
 563   for (int type = kFirstTypeCode; type < kTypeCodeCount; ++type) {
 564     int max = external_references->max_id(type) + 1;
 565     encodings_[type] = NewArray<Address>(max + 1);
 566   }
 567   for (int i = 0; i < external_references->size(); ++i) {
 568     Put(external_references->code(i), external_references->address(i));
 569   }
 570 }
 571
 572
 573 ExternalReferenceDecoder::~ExternalReferenceDecoder() {
 574   for (int type = kFirstTypeCode; type < kTypeCodeCount; ++type) {
 575     DeleteArray(encodings_[type]);
 576   }
 577   DeleteArray(encodings_);
 578 }
 579
 580
 581 bool Serializer::serialization_enabled_ = false;
 582 bool Serializer::too_late_to_enable_now_ = false;
 583
 584
 585 Deserializer::Deserializer(SnapshotByteSource* source)
 586     : isolate_(NULL),
 587       source_(source),
 588       external_reference_decoder_(NULL) {
 589 }
 590
 591
 592 // This routine both allocates a new object, and also keeps
 593 // track of where objects have been allocated so that we can
 594 // fix back references when deserializing.
 595 Address Deserializer::Allocate(int space_index, Space* space, int size) {
 596   Address address;
 597   if (!SpaceIsLarge(space_index)) {
 598     ASSERT(!SpaceIsPaged(space_index) ||
 599            size <= Page::kPageSize - Page::kObjectStartOffset);
 600     MaybeObject* maybe_new_allocation;
 601     if (space_index == NEW_SPACE) {
 602       maybe_new_allocation =
 603           reinterpret_cast<NewSpace*>(space)->AllocateRaw(size);
 604     } else {
 605       maybe_new_allocation =
 606           reinterpret_cast<PagedSpace*>(space)->AllocateRaw(size);
 607     }
 608     ASSERT(!maybe_new_allocation->IsFailure());
 609     Object* new_allocation = maybe_new_allocation->ToObjectUnchecked();
 610     HeapObject* new_object = HeapObject::cast(new_allocation);
 611     address = new_object->address();
 612     high_water_[space_index] = address + size;
 613   } else {
 614     ASSERT(SpaceIsLarge(space_index));
 615     LargeObjectSpace* lo_space = reinterpret_cast<LargeObjectSpace*>(space);
 616     Object* new_allocation;
 617     if (space_index == kLargeData || space_index == kLargeFixedArray) {
 618       new_allocation =
 619           lo_space->AllocateRaw(size, NOT_EXECUTABLE)->ToObjectUnchecked();
 620     } else {
 621       ASSERT_EQ(kLargeCode, space_index);
 622       new_allocation =
 623           lo_space->AllocateRaw(size, EXECUTABLE)->ToObjectUnchecked();
 624     }
 625     HeapObject* new_object = HeapObject::cast(new_allocation);
 626     // Record all large objects in the same space.
 627     address = new_object->address();
 628     pages_[LO_SPACE].Add(address);
 629   }
 630   last_object_address_ = address;
 631   return address;
 632 }
 633
 634
 635 // This returns the address of an object that has been described in the
 636 // snapshot as being offset bytes back in a particular space.
 637 HeapObject* Deserializer::GetAddressFromEnd(int space) {
 638   int offset = source_->GetInt();
 639   ASSERT(!SpaceIsLarge(space));
 640   offset <<= kObjectAlignmentBits;
 641   return HeapObject::FromAddress(high_water_[space] - offset);
 642 }
 643
 644
 645 // This returns the address of an object that has been described in the
 646 // snapshot as being offset bytes into a particular space.
 647 HeapObject* Deserializer::GetAddressFromStart(int space) {
 648   int offset = source_->GetInt();
 649   if (SpaceIsLarge(space)) {
 650     // Large spaces have one object per 'page'.
 651     return HeapObject::FromAddress(pages_[LO_SPACE][offset]);
 652   }
 653   offset <<= kObjectAlignmentBits;
 654   if (space == NEW_SPACE) {
 655     // New space has only one space - numbered 0.
 656     return HeapObject::FromAddress(pages_[space][0] + offset);
 657   }
 658   ASSERT(SpaceIsPaged(space));
 659   int page_of_pointee = offset >> kPageSizeBits;
 660   Address object_address = pages_[space][page_of_pointee] +
 661                            (offset & Page::kPageAlignmentMask);
 662   return HeapObject::FromAddress(object_address);
 663 }
 664
 665
 666 void Deserializer::Deserialize() {
 667   isolate_ = Isolate::Current();
 668   ASSERT(isolate_ != NULL);
 669   // Don't GC while deserializing - just expand the heap.
 670   AlwaysAllocateScope always_allocate;
 671   // Don't use the free lists while deserializing.
 672   LinearAllocationScope allocate_linearly;
 673   // No active threads.
 674   ASSERT_EQ(NULL, isolate_->thread_manager()->FirstThreadStateInUse());
 675   // No active handles.
 676   ASSERT(isolate_->handle_scope_implementer()->blocks()->is_empty());
 677   // Make sure the entire partial snapshot cache is traversed, filling it with
 678   // valid object pointers.
 679   isolate_->set_serialize_partial_snapshot_cache_length(
 680       Isolate::kPartialSnapshotCacheCapacity);
 681   ASSERT_EQ(NULL, external_reference_decoder_);
 682   external_reference_decoder_ = new ExternalReferenceDecoder();
 683   isolate_->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
 684   isolate_->heap()->IterateWeakRoots(this, VISIT_ALL);
 685
 686   isolate_->heap()->set_global_contexts_list(
 687       isolate_->heap()->undefined_value());
 688
 689   // Update data pointers to the external strings containing natives sources.
 690   for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
 691     Object* source = isolate_->heap()->natives_source_cache()->get(i);
 692     if (!source->IsUndefined()) {
 693       ExternalAsciiString::cast(source)->update_data_cache();
 694     }
 695   }
 696 }
 697
 698
 699 void Deserializer::DeserializePartial(Object** root) {
 700   isolate_ = Isolate::Current();
 701   // Don't GC while deserializing - just expand the heap.
 702   AlwaysAllocateScope always_allocate;
 703   // Don't use the free lists while deserializing.
 704   LinearAllocationScope allocate_linearly;
 705   if (external_reference_decoder_ == NULL) {
 706     external_reference_decoder_ = new ExternalReferenceDecoder();
 707   }
 708   VisitPointer(root);
 709 }
 710
 711
 712 Deserializer::~Deserializer() {
 713   ASSERT(source_->AtEOF());
 714   if (external_reference_decoder_) {
 715     delete external_reference_decoder_;
 716     external_reference_decoder_ = NULL;
 717   }
 718 }
 719
 720
 721 // This is called on the roots.  It is the driver of the deserialization
 722 // process.  It is also called on the body of each function.
 723 void Deserializer::VisitPointers(Object** start, Object** end) {
 724   // The space must be new space.  Any other space would cause ReadChunk to try
 725   // to update the remembered using NULL as the address.
 726   ReadChunk(start, end, NEW_SPACE, NULL);
 727 }
 728
 729
 730 // This routine writes the new object into the pointer provided and then
 731 // returns true if the new object was in young space and false otherwise.
 732 // The reason for this strange interface is that otherwise the object is
 733 // written very late, which means the FreeSpace map is not set up by the
 734 // time we need to use it to mark the space at the end of a page free.
 735 void Deserializer::ReadObject(int space_number,
 736                               Space* space,
 737                               Object** write_back) {
 738   int size = source_->GetInt() << kObjectAlignmentBits;
 739   Address address = Allocate(space_number, space, size);
 740   *write_back = HeapObject::FromAddress(address);
 741   Object** current = reinterpret_cast<Object**>(address);
 742   Object** limit = current + (size >> kPointerSizeLog2);
 743   if (FLAG_log_snapshot_positions) {
 744     LOG(isolate_, SnapshotPositionEvent(address, source_->position()));
 745   }
 746   ReadChunk(current, limit, space_number, address);
 747 #ifdef DEBUG
 748   bool is_codespace = (space == HEAP->code_space()) ||
 749       ((space == HEAP->lo_space()) && (space_number == kLargeCode));
 750   ASSERT(HeapObject::FromAddress(address)->IsCode() == is_codespace);
 751 #endif
 752 }
 753
 754
 755 // This macro is always used with a constant argument so it should all fold
 756 // away to almost nothing in the generated code.  It might be nicer to do this
 757 // with the ternary operator but there are type issues with that.
 758 #define ASSIGN_DEST_SPACE(space_number)                                        \
 759   Space* dest_space;                                                           \
 760   if (space_number == NEW_SPACE) {                                             \
 761     dest_space = isolate->heap()->new_space();                                \
 762   } else if (space_number == OLD_POINTER_SPACE) {                              \
 763     dest_space = isolate->heap()->old_pointer_space();                         \
 764   } else if (space_number == OLD_DATA_SPACE) {                                 \
 765     dest_space = isolate->heap()->old_data_space();                            \
 766   } else if (space_number == CODE_SPACE) {                                     \
 767     dest_space = isolate->heap()->code_space();                                \
 768   } else if (space_number == MAP_SPACE) {                                      \
 769     dest_space = isolate->heap()->map_space();                                 \
 770   } else if (space_number == CELL_SPACE) {                                     \
 771     dest_space = isolate->heap()->cell_space();                                \
 772   } else {                                                                     \
 773     ASSERT(space_number >= LO_SPACE);                                          \
 774     dest_space = isolate->heap()->lo_space();                                  \
 775   }
 776
 777
 778 static const int kUnknownOffsetFromStart = -1;
 779
 780
 781 void Deserializer::ReadChunk(Object** current,
 782                              Object** limit,
 783                              int source_space,
 784                              Address current_object_address) {
 785   Isolate* const isolate = isolate_;
 786   bool write_barrier_needed = (current_object_address != NULL &&
 787                                source_space != NEW_SPACE &&
 788                                source_space != CELL_SPACE &&
 789                                source_space != CODE_SPACE &&
 790                                source_space != OLD_DATA_SPACE);
 791   while (current < limit) {
 792     int data = source_->Get();
 793     switch (data) {
 794 #define CASE_STATEMENT(where, how, within, space_number)                       \
 795       case where + how + within + space_number:                                \
 796       ASSERT((where & ~kPointedToMask) == 0);                                  \
 797       ASSERT((how & ~kHowToCodeMask) == 0);                                    \
 798       ASSERT((within & ~kWhereToPointMask) == 0);                              \
 799       ASSERT((space_number & ~kSpaceMask) == 0);
 800
 801 #define CASE_BODY(where, how, within, space_number_if_any, offset_from_start)  \
 802       {                                                                        \
 803         bool emit_write_barrier = false;                                       \
 804         bool current_was_incremented = false;                                  \
 805         int space_number =  space_number_if_any == kAnyOldSpace ?              \
 806                             (data & kSpaceMask) : space_number_if_any;         \
 807         if (where == kNewObject && how == kPlain && within == kStartOfObject) {\
 808           ASSIGN_DEST_SPACE(space_number)                                      \
 809           ReadObject(space_number, dest_space, current);                       \
 810           emit_write_barrier = (space_number == NEW_SPACE);                    \
 811         } else {                                                               \
 812           Object* new_object = NULL;  /* May not be a real Object pointer. */  \
 813           if (where == kNewObject) {                                           \
 814             ASSIGN_DEST_SPACE(space_number)                                    \
 815             ReadObject(space_number, dest_space, &new_object);                 \
 816           } else if (where == kRootArray) {                                    \
 817             int root_id = source_->GetInt();                                   \
 818             new_object = isolate->heap()->roots_array_start()[root_id];        \
 819             emit_write_barrier = isolate->heap()->InNewSpace(new_object);      \
 820           } else if (where == kPartialSnapshotCache) {                         \
 821             int cache_index = source_->GetInt();                               \
 822             new_object = isolate->serialize_partial_snapshot_cache()           \
 823                 [cache_index];                                                 \
 824             emit_write_barrier = isolate->heap()->InNewSpace(new_object);      \
 825           } else if (where == kExternalReference) {                            \
 826             int reference_id = source_->GetInt();                              \
 827             Address address = external_reference_decoder_->                    \
 828                 Decode(reference_id);                                          \
 829             new_object = reinterpret_cast<Object*>(address);                   \
 830           } else if (where == kBackref) {                                      \
 831             emit_write_barrier = (space_number == NEW_SPACE);                  \
 832             new_object = GetAddressFromEnd(data & kSpaceMask);                 \
 833           } else {                                                             \
 834             ASSERT(where == kFromStart);                                       \
 835             if (offset_from_start == kUnknownOffsetFromStart) {                \
 836               emit_write_barrier = (space_number == NEW_SPACE);                \
 837               new_object = GetAddressFromStart(data & kSpaceMask);             \
 838             } else {                                                           \
 839               Address object_address = pages_[space_number][0] +               \
 840                   (offset_from_start << kObjectAlignmentBits);                 \
 841               new_object = HeapObject::FromAddress(object_address);            \
 842             }                                                                  \
 843           }                                                                    \
 844           if (within == kFirstInstruction) {                                   \
 845             Code* new_code_object = reinterpret_cast<Code*>(new_object);       \
 846             new_object = reinterpret_cast<Object*>(                            \
 847                 new_code_object->instruction_start());                         \
 848           }                                                                    \
 849           if (how == kFromCode) {                                              \
 850             Address location_of_branch_data =                                  \
 851                 reinterpret_cast<Address>(current);                            \
 852             Assembler::deserialization_set_special_target_at(                  \
 853                 location_of_branch_data,                                       \
 854                 reinterpret_cast<Address>(new_object));                        \
 855             location_of_branch_data += Assembler::kSpecialTargetSize;          \
 856             current = reinterpret_cast<Object**>(location_of_branch_data);     \
 857             current_was_incremented = true;                                    \
 858           } else {                                                             \
 859             *current = new_object;                                             \
 860           }                                                                    \
 861         }                                                                      \
 862         if (emit_write_barrier && write_barrier_needed) {                      \
 863           Address current_address = reinterpret_cast<Address>(current);        \
 864           isolate->heap()->RecordWrite(                                        \
 865               current_object_address,                                          \
 866               static_cast<int>(current_address - current_object_address));     \
 867         }                                                                      \
 868         if (!current_was_incremented) {                                        \
 869           current++;                                                           \
 870         }                                                                      \
 871         break;                                                                 \
 872       }                                                                        \
 873
 874 // This generates a case and a body for each space.  The large object spaces are
 875 // very rare in snapshots so they are grouped in one body.
 876 #define ONE_PER_SPACE(where, how, within)                                      \
 877   CASE_STATEMENT(where, how, within, NEW_SPACE)                                \
 878   CASE_BODY(where, how, within, NEW_SPACE, kUnknownOffsetFromStart)            \
 879   CASE_STATEMENT(where, how, within, OLD_DATA_SPACE)                           \
 880   CASE_BODY(where, how, within, OLD_DATA_SPACE, kUnknownOffsetFromStart)       \
 881   CASE_STATEMENT(where, how, within, OLD_POINTER_SPACE)                        \
 882   CASE_BODY(where, how, within, OLD_POINTER_SPACE, kUnknownOffsetFromStart)    \
 883   CASE_STATEMENT(where, how, within, CODE_SPACE)                               \
 884   CASE_BODY(where, how, within, CODE_SPACE, kUnknownOffsetFromStart)           \
 885   CASE_STATEMENT(where, how, within, CELL_SPACE)                               \
 886   CASE_BODY(where, how, within, CELL_SPACE, kUnknownOffsetFromStart)           \
 887   CASE_STATEMENT(where, how, within, MAP_SPACE)                                \
 888   CASE_BODY(where, how, within, MAP_SPACE, kUnknownOffsetFromStart)            \
 889   CASE_STATEMENT(where, how, within, kLargeData)                               \
 890   CASE_STATEMENT(where, how, within, kLargeCode)                               \
 891   CASE_STATEMENT(where, how, within, kLargeFixedArray)                         \
 892   CASE_BODY(where, how, within, kAnyOldSpace, kUnknownOffsetFromStart)
 893
 894 // This generates a case and a body for the new space (which has to do extra
 895 // write barrier handling) and handles the other spaces with 8 fall-through
 896 // cases and one body.
 897 #define ALL_SPACES(where, how, within)                                         \
 898   CASE_STATEMENT(where, how, within, NEW_SPACE)                                \
 899   CASE_BODY(where, how, within, NEW_SPACE, kUnknownOffsetFromStart)            \
 900   CASE_STATEMENT(where, how, within, OLD_DATA_SPACE)                           \
 901   CASE_STATEMENT(where, how, within, OLD_POINTER_SPACE)                        \
 902   CASE_STATEMENT(where, how, within, CODE_SPACE)                               \
 903   CASE_STATEMENT(where, how, within, CELL_SPACE)                               \
 904   CASE_STATEMENT(where, how, within, MAP_SPACE)                                \
 905   CASE_STATEMENT(where, how, within, kLargeData)                               \
 906   CASE_STATEMENT(where, how, within, kLargeCode)                               \
 907   CASE_STATEMENT(where, how, within, kLargeFixedArray)                         \
 908   CASE_BODY(where, how, within, kAnyOldSpace, kUnknownOffsetFromStart)
 909
 910 #define ONE_PER_CODE_SPACE(where, how, within)                                 \
 911   CASE_STATEMENT(where, how, within, CODE_SPACE)                               \
 912   CASE_BODY(where, how, within, CODE_SPACE, kUnknownOffsetFromStart)           \
 913   CASE_STATEMENT(where, how, within, kLargeCode)                               \
 914   CASE_BODY(where, how, within, kLargeCode, kUnknownOffsetFromStart)
 915
 916 #define FOUR_CASES(byte_code)             \
 917   case byte_code:                         \
 918   case byte_code + 1:                     \
 919   case byte_code + 2:                     \
 920   case byte_code + 3:
 921
 922 #define SIXTEEN_CASES(byte_code)          \
 923   FOUR_CASES(byte_code)                   \
 924   FOUR_CASES(byte_code + 4)               \
 925   FOUR_CASES(byte_code + 8)               \
 926   FOUR_CASES(byte_code + 12)
 927
 928       // We generate 15 cases and bodies that process special tags that combine
 929       // the raw data tag and the length into one byte.
 930 #define RAW_CASE(index, size)                                      \
 931       case kRawData + index: {                                     \
 932         byte* raw_data_out = reinterpret_cast<byte*>(current);     \
 933         source_->CopyRaw(raw_data_out, size);                      \
 934         current = reinterpret_cast<Object**>(raw_data_out + size); \
 935         break;                                                     \
 936       }
 937       COMMON_RAW_LENGTHS(RAW_CASE)
 938 #undef RAW_CASE
 939
 940       // Deserialize a chunk of raw data that doesn't have one of the popular
 941       // lengths.
 942       case kRawData: {
 943         int size = source_->GetInt();
 944         byte* raw_data_out = reinterpret_cast<byte*>(current);
 945         source_->CopyRaw(raw_data_out, size);
 946         current = reinterpret_cast<Object**>(raw_data_out + size);
 947         break;
 948       }
 949
 950       SIXTEEN_CASES(kRootArrayLowConstants)
 951       SIXTEEN_CASES(kRootArrayHighConstants) {
 952         int root_id = RootArrayConstantFromByteCode(data);
 953         Object* object = isolate->heap()->roots_array_start()[root_id];
 954         ASSERT(!isolate->heap()->InNewSpace(object));
 955         *current++ = object;
 956         break;
 957       }
 958
 959       case kRepeat: {
 960         int repeats = source_->GetInt();
 961         Object* object = current[-1];
 962         ASSERT(!isolate->heap()->InNewSpace(object));
 963         for (int i = 0; i < repeats; i++) current[i] = object;
 964         current += repeats;
 965         break;
 966       }
 967
 968       STATIC_ASSERT(kRootArrayNumberOfConstantEncodings ==
 969                     Heap::kOldSpaceRoots);
 970       STATIC_ASSERT(kMaxRepeats == 12);
 971       FOUR_CASES(kConstantRepeat)
 972       FOUR_CASES(kConstantRepeat + 4)
 973       FOUR_CASES(kConstantRepeat + 8) {
 974         int repeats = RepeatsForCode(data);
 975         Object* object = current[-1];
 976         ASSERT(!isolate->heap()->InNewSpace(object));
 977         for (int i = 0; i < repeats; i++) current[i] = object;
 978         current += repeats;
 979         break;
 980       }
 981
 982       // Deserialize a new object and write a pointer to it to the current
 983       // object.
 984       ONE_PER_SPACE(kNewObject, kPlain, kStartOfObject)
 985       // Support for direct instruction pointers in functions
 986       ONE_PER_CODE_SPACE(kNewObject, kPlain, kFirstInstruction)
 987       // Deserialize a new code object and write a pointer to its first
 988       // instruction to the current code object.
 989       ONE_PER_SPACE(kNewObject, kFromCode, kFirstInstruction)
 990       // Find a recently deserialized object using its offset from the current
 991       // allocation point and write a pointer to it to the current object.
 992       ALL_SPACES(kBackref, kPlain, kStartOfObject)
 993 #if V8_TARGET_ARCH_MIPS
 994       // Deserialize a new object from pointer found in code and write
 995       // a pointer to it to the current object. Required only for MIPS, and
 996       // omitted on the other architectures because it is fully unrolled and
 997       // would cause bloat.
 998       ONE_PER_SPACE(kNewObject, kFromCode, kStartOfObject)
 999       // Find a recently deserialized code object using its offset from the
1000       // current allocation point and write a pointer to it to the current
1001       // object. Required only for MIPS.
1002       ALL_SPACES(kBackref, kFromCode, kStartOfObject)
1003       // Find an already deserialized code object using its offset from
1004       // the start and write a pointer to it to the current object.
1005       // Required only for MIPS.
1006       ALL_SPACES(kFromStart, kFromCode, kStartOfObject)
1007 #endif
1008       // Find a recently deserialized code object using its offset from the
1009       // current allocation point and write a pointer to its first instruction
1010       // to the current code object or the instruction pointer in a function
1011       // object.
1012       ALL_SPACES(kBackref, kFromCode, kFirstInstruction)
1013       ALL_SPACES(kBackref, kPlain, kFirstInstruction)
1014       // Find an already deserialized object using its offset from the start
1015       // and write a pointer to it to the current object.
1016       ALL_SPACES(kFromStart, kPlain, kStartOfObject)
1017       ALL_SPACES(kFromStart, kPlain, kFirstInstruction)
1018       // Find an already deserialized code object using its offset from the
1019       // start and write a pointer to its first instruction to the current code
1020       // object.
1021       ALL_SPACES(kFromStart, kFromCode, kFirstInstruction)
1022       // Find an object in the roots array and write a pointer to it to the
1023       // current object.
1024       CASE_STATEMENT(kRootArray, kPlain, kStartOfObject, 0)
1025       CASE_BODY(kRootArray, kPlain, kStartOfObject, 0, kUnknownOffsetFromStart)
1026       // Find an object in the partial snapshots cache and write a pointer to it
1027       // to the current object.
1028       CASE_STATEMENT(kPartialSnapshotCache, kPlain, kStartOfObject, 0)
1029       CASE_BODY(kPartialSnapshotCache,
1030                 kPlain,
1031                 kStartOfObject,
1032                 0,
1033                 kUnknownOffsetFromStart)
1034       // Find an code entry in the partial snapshots cache and
1035       // write a pointer to it to the current object.
1036       CASE_STATEMENT(kPartialSnapshotCache, kPlain, kFirstInstruction, 0)
1037       CASE_BODY(kPartialSnapshotCache,
1038                 kPlain,
1039                 kFirstInstruction,
1040                 0,
1041                 kUnknownOffsetFromStart)
1042       // Find an external reference and write a pointer to it to the current
1043       // object.
1044       CASE_STATEMENT(kExternalReference, kPlain, kStartOfObject, 0)
1045       CASE_BODY(kExternalReference,
1046                 kPlain,
1047                 kStartOfObject,
1048                 0,
1049                 kUnknownOffsetFromStart)
1050       // Find an external reference and write a pointer to it in the current
1051       // code object.
1052       CASE_STATEMENT(kExternalReference, kFromCode, kStartOfObject, 0)
1053       CASE_BODY(kExternalReference,
1054                 kFromCode,
1055                 kStartOfObject,
1056                 0,
1057                 kUnknownOffsetFromStart)
1058
1059 #undef CASE_STATEMENT
1060 #undef CASE_BODY
1061 #undef ONE_PER_SPACE
1062 #undef ALL_SPACES
1063 #undef ASSIGN_DEST_SPACE
1064
1065       case kNewPage: {
1066         int space = source_->Get();
1067         pages_[space].Add(last_object_address_);
1068         if (space == CODE_SPACE) {
1069           CPU::FlushICache(last_object_address_, Page::kPageSize);
1070         }
1071         break;
1072       }
1073
1074       case kSkip: {
1075         current++;
1076         break;
1077       }
1078
1079       case kNativesStringResource: {
1080         int index = source_->Get();
1081         Vector<const char> source_vector = Natives::GetRawScriptSource(index);
1082         NativesExternalStringResource* resource =
1083             new NativesExternalStringResource(isolate->bootstrapper(),
1084                                               source_vector.start(),
1085                                               source_vector.length());
1086         *current++ = reinterpret_cast<Object*>(resource);
1087         break;
1088       }
1089
1090       case kSynchronize: {
1091         // If we get here then that indicates that you have a mismatch between
1092         // the number of GC roots when serializing and deserializing.
1093         UNREACHABLE();
1094       }
1095
1096       default:
1097         UNREACHABLE();
1098     }
1099   }
1100   ASSERT_EQ(current, limit);
1101 }
1102
1103
1104 void SnapshotByteSink::PutInt(uintptr_t integer, const char* description) {
1105   const int max_shift = ((kPointerSize * kBitsPerByte) / 7) * 7;
1106   for (int shift = max_shift; shift > 0; shift -= 7) {
1107     if (integer >= static_cast<uintptr_t>(1u) << shift) {
1108       Put((static_cast<int>((integer >> shift)) & 0x7f) | 0x80, "IntPart");
1109     }
1110   }
1111   PutSection(static_cast<int>(integer & 0x7f), "IntLastPart");
1112 }
1113
1114
1115 Serializer::Serializer(SnapshotByteSink* sink)
1116     : sink_(sink),
1117       current_root_index_(0),
1118       external_reference_encoder_(new ExternalReferenceEncoder),
1119       large_object_total_(0),
1120       root_index_wave_front_(0) {
1121   isolate_ = Isolate::Current();
1122   // The serializer is meant to be used only to generate initial heap images
1123   // from a context in which there is only one isolate.
1124   ASSERT(isolate_->IsDefaultIsolate());
1125   for (int i = 0; i <= LAST_SPACE; i++) {
1126     fullness_[i] = 0;
1127   }
1128 }
1129
1130
1131 Serializer::~Serializer() {
1132   delete external_reference_encoder_;
1133 }
1134
1135
1136 void StartupSerializer::SerializeStrongReferences() {
1137   Isolate* isolate = Isolate::Current();
1138   // No active threads.
1139   CHECK_EQ(NULL, Isolate::Current()->thread_manager()->FirstThreadStateInUse());
1140   // No active or weak handles.
1141   CHECK(isolate->handle_scope_implementer()->blocks()->is_empty());
1142   CHECK_EQ(0, isolate->global_handles()->NumberOfWeakHandles());
1143   // We don't support serializing installed extensions.
1144   CHECK(!isolate->has_installed_extensions());
1145
1146   HEAP->IterateStrongRoots(this, VISIT_ONLY_STRONG);
1147 }
1148
1149
1150 void PartialSerializer::Serialize(Object** object) {
1151   this->VisitPointer(object);
1152   Isolate* isolate = Isolate::Current();
1153
1154   // After we have done the partial serialization the partial snapshot cache
1155   // will contain some references needed to decode the partial snapshot.  We
1156   // fill it up with undefineds so it has a predictable length so the
1157   // deserialization code doesn't need to know the length.
1158   for (int index = isolate->serialize_partial_snapshot_cache_length();
1159        index < Isolate::kPartialSnapshotCacheCapacity;
1160        index++) {
1161     isolate->serialize_partial_snapshot_cache()[index] =
1162         isolate->heap()->undefined_value();
1163     startup_serializer_->VisitPointer(
1164         &isolate->serialize_partial_snapshot_cache()[index]);
1165   }
1166   isolate->set_serialize_partial_snapshot_cache_length(
1167       Isolate::kPartialSnapshotCacheCapacity);
1168 }
1169
1170
1171 void Serializer::VisitPointers(Object** start, Object** end) {
1172   Isolate* isolate = Isolate::Current();
1173
1174   for (Object** current = start; current < end; current++) {
1175     if (start == isolate->heap()->roots_array_start()) {
1176       root_index_wave_front_ =
1177           Max(root_index_wave_front_, static_cast<intptr_t>(current - start));
1178     }
1179     if (reinterpret_cast<Address>(current) ==
1180         isolate->heap()->store_buffer()->TopAddress()) {
1181       sink_->Put(kSkip, "Skip");
1182     } else if ((*current)->IsSmi()) {
1183       sink_->Put(kRawData, "RawData");
1184       sink_->PutInt(kPointerSize, "length");
1185       for (int i = 0; i < kPointerSize; i++) {
1186         sink_->Put(reinterpret_cast<byte*>(current)[i], "Byte");
1187       }
1188     } else {
1189       SerializeObject(*current, kPlain, kStartOfObject);
1190     }
1191   }
1192 }
1193
1194
1195 // This ensures that the partial snapshot cache keeps things alive during GC and
1196 // tracks their movement.  When it is called during serialization of the startup
1197 // snapshot the partial snapshot is empty, so nothing happens.  When the partial
1198 // (context) snapshot is created, this array is populated with the pointers that
1199 // the partial snapshot will need. As that happens we emit serialized objects to
1200 // the startup snapshot that correspond to the elements of this cache array.  On
1201 // deserialization we therefore need to visit the cache array.  This fills it up
1202 // with pointers to deserialized objects.
1203 void SerializerDeserializer::Iterate(ObjectVisitor* visitor) {
1204   Isolate* isolate = Isolate::Current();
1205   visitor->VisitPointers(
1206       isolate->serialize_partial_snapshot_cache(),
1207       &isolate->serialize_partial_snapshot_cache()[
1208           isolate->serialize_partial_snapshot_cache_length()]);
1209 }
1210
1211
1212 // When deserializing we need to set the size of the snapshot cache.  This means
1213 // the root iteration code (above) will iterate over array elements, writing the
1214 // references to deserialized objects in them.
1215 void SerializerDeserializer::SetSnapshotCacheSize(int size) {
1216   Isolate::Current()->set_serialize_partial_snapshot_cache_length(size);
1217 }
1218
1219
1220 int PartialSerializer::PartialSnapshotCacheIndex(HeapObject* heap_object) {
1221   Isolate* isolate = Isolate::Current();
1222
1223   for (int i = 0;
1224        i < isolate->serialize_partial_snapshot_cache_length();
1225        i++) {
1226     Object* entry = isolate->serialize_partial_snapshot_cache()[i];
1227     if (entry == heap_object) return i;
1228   }
1229
1230   // We didn't find the object in the cache.  So we add it to the cache and
1231   // then visit the pointer so that it becomes part of the startup snapshot
1232   // and we can refer to it from the partial snapshot.
1233   int length = isolate->serialize_partial_snapshot_cache_length();
1234   CHECK(length < Isolate::kPartialSnapshotCacheCapacity);
1235   isolate->serialize_partial_snapshot_cache()[length] = heap_object;
1236   startup_serializer_->VisitPointer(
1237       &isolate->serialize_partial_snapshot_cache()[length]);
1238   // We don't recurse from the startup snapshot generator into the partial
1239   // snapshot generator.
1240   ASSERT(length == isolate->serialize_partial_snapshot_cache_length());
1241   isolate->set_serialize_partial_snapshot_cache_length(length + 1);
1242   return length;
1243 }
1244
1245
1246 int Serializer::RootIndex(HeapObject* heap_object, HowToCode from) {
1247   Heap* heap = HEAP;
1248   if (heap->InNewSpace(heap_object)) return kInvalidRootIndex;
1249   for (int i = 0; i < root_index_wave_front_; i++) {
1250     Object* root = heap->roots_array_start()[i];
1251     if (!root->IsSmi() && root == heap_object) {
1252 #if V8_TARGET_ARCH_MIPS
1253       if (from == kFromCode) {
1254         // In order to avoid code bloat in the deserializer we don't have
1255         // support for the encoding that specifies a particular root should
1256         // be written into the lui/ori instructions on MIPS.  Therefore we
1257         // should not generate such serialization data for MIPS.
1258         return kInvalidRootIndex;
1259       }
1260 #endif
1261       return i;
1262     }
1263   }
1264   return kInvalidRootIndex;
1265 }
1266
1267
1268 // Encode the location of an already deserialized object in order to write its
1269 // location into a later object.  We can encode the location as an offset from
1270 // the start of the deserialized objects or as an offset backwards from the
1271 // current allocation pointer.
1272 void Serializer::SerializeReferenceToPreviousObject(
1273     int space,
1274     int address,
1275     HowToCode how_to_code,
1276     WhereToPoint where_to_point) {
1277   int offset = CurrentAllocationAddress(space) - address;
1278   bool from_start = true;
1279   if (SpaceIsPaged(space)) {
1280     // For paged space it is simple to encode back from current allocation if
1281     // the object is on the same page as the current allocation pointer.
1282     if ((CurrentAllocationAddress(space) >> kPageSizeBits) ==
1283         (address >> kPageSizeBits)) {
1284       from_start = false;
1285       address = offset;
1286     }
1287   } else if (space == NEW_SPACE) {
1288     // For new space it is always simple to encode back from current allocation.
1289     if (offset < address) {
1290       from_start = false;
1291       address = offset;
1292     }
1293   }
1294   // If we are actually dealing with real offsets (and not a numbering of
1295   // all objects) then we should shift out the bits that are always 0.
1296   if (!SpaceIsLarge(space)) address >>= kObjectAlignmentBits;
1297   if (from_start) {
1298     sink_->Put(kFromStart + how_to_code + where_to_point + space, "RefSer");
1299     sink_->PutInt(address, "address");
1300   } else {
1301     sink_->Put(kBackref + how_to_code + where_to_point + space, "BackRefSer");
1302     sink_->PutInt(address, "address");
1303   }
1304 }
1305
1306
1307 void StartupSerializer::SerializeObject(
1308     Object* o,
1309     HowToCode how_to_code,
1310     WhereToPoint where_to_point) {
1311   CHECK(o->IsHeapObject());
1312   HeapObject* heap_object = HeapObject::cast(o);
1313
1314   int root_index;
1315   if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
1316     PutRoot(root_index, heap_object, how_to_code, where_to_point);
1317     return;
1318   }
1319
1320   if (address_mapper_.IsMapped(heap_object)) {
1321     int space = SpaceOfAlreadySerializedObject(heap_object);
1322     int address = address_mapper_.MappedTo(heap_object);
1323     SerializeReferenceToPreviousObject(space,
1324                                        address,
1325                                        how_to_code,
1326                                        where_to_point);
1327   } else {
1328     // Object has not yet been serialized.  Serialize it here.
1329     ObjectSerializer object_serializer(this,
1330                                        heap_object,
1331                                        sink_,
1332                                        how_to_code,
1333                                        where_to_point);
1334     object_serializer.Serialize();
1335   }
1336 }
1337
1338
1339 void StartupSerializer::SerializeWeakReferences() {
1340   for (int i = Isolate::Current()->serialize_partial_snapshot_cache_length();
1341        i < Isolate::kPartialSnapshotCacheCapacity;
1342        i++) {
1343     sink_->Put(kRootArray + kPlain + kStartOfObject, "RootSerialization");
1344     sink_->PutInt(Heap::kUndefinedValueRootIndex, "root_index");
1345   }
1346   HEAP->IterateWeakRoots(this, VISIT_ALL);
1347 }
1348
1349
1350 void Serializer::PutRoot(int root_index,
1351                          HeapObject* object,
1352                          SerializerDeserializer::HowToCode how_to_code,
1353                          SerializerDeserializer::WhereToPoint where_to_point) {
1354   if (how_to_code == kPlain &&
1355       where_to_point == kStartOfObject &&
1356       root_index < kRootArrayNumberOfConstantEncodings &&
1357       !HEAP->InNewSpace(object)) {
1358     if (root_index < kRootArrayNumberOfLowConstantEncodings) {
1359       sink_->Put(kRootArrayLowConstants + root_index, "RootLoConstant");
1360     } else {
1361       sink_->Put(kRootArrayHighConstants + root_index -
1362                      kRootArrayNumberOfLowConstantEncodings,
1363                  "RootHiConstant");
1364     }
1365   } else {
1366     sink_->Put(kRootArray + how_to_code + where_to_point, "RootSerialization");
1367     sink_->PutInt(root_index, "root_index");
1368   }
1369 }
1370
1371
1372 void PartialSerializer::SerializeObject(
1373     Object* o,
1374     HowToCode how_to_code,
1375     WhereToPoint where_to_point) {
1376   CHECK(o->IsHeapObject());
1377   HeapObject* heap_object = HeapObject::cast(o);
1378
1379   if (heap_object->IsMap()) {
1380     // The code-caches link to context-specific code objects, which
1381     // the startup and context serializes cannot currently handle.
1382     ASSERT(Map::cast(heap_object)->code_cache() ==
1383            heap_object->GetHeap()->raw_unchecked_empty_fixed_array());
1384   }
1385
1386   int root_index;
1387   if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
1388     PutRoot(root_index, heap_object, how_to_code, where_to_point);
1389     return;
1390   }
1391
1392   if (ShouldBeInThePartialSnapshotCache(heap_object)) {
1393     int cache_index = PartialSnapshotCacheIndex(heap_object);
1394     sink_->Put(kPartialSnapshotCache + how_to_code + where_to_point,
1395                "PartialSnapshotCache");
1396     sink_->PutInt(cache_index, "partial_snapshot_cache_index");
1397     return;
1398   }
1399
1400   // Pointers from the partial snapshot to the objects in the startup snapshot
1401   // should go through the root array or through the partial snapshot cache.
1402   // If this is not the case you may have to add something to the root array.
1403   ASSERT(!startup_serializer_->address_mapper()->IsMapped(heap_object));
1404   // All the symbols that the partial snapshot needs should be either in the
1405   // root table or in the partial snapshot cache.
1406   ASSERT(!heap_object->IsSymbol());
1407
1408   if (address_mapper_.IsMapped(heap_object)) {
1409     int space = SpaceOfAlreadySerializedObject(heap_object);
1410     int address = address_mapper_.MappedTo(heap_object);
1411     SerializeReferenceToPreviousObject(space,
1412                                        address,
1413                                        how_to_code,
1414                                        where_to_point);
1415   } else {
1416     // Object has not yet been serialized.  Serialize it here.
1417     ObjectSerializer serializer(this,
1418                                 heap_object,
1419                                 sink_,
1420                                 how_to_code,
1421                                 where_to_point);
1422     serializer.Serialize();
1423   }
1424 }
1425
1426
1427 void Serializer::ObjectSerializer::Serialize() {
1428   int space = Serializer::SpaceOfObject(object_);
1429   int size = object_->Size();
1430
1431   sink_->Put(kNewObject + reference_representation_ + space,
1432              "ObjectSerialization");
1433   sink_->PutInt(size >> kObjectAlignmentBits, "Size in words");
1434
1435   LOG(i::Isolate::Current(),
1436       SnapshotPositionEvent(object_->address(), sink_->Position()));
1437
1438   // Mark this object as already serialized.
1439   bool start_new_page;
1440   int offset = serializer_->Allocate(space, size, &start_new_page);
1441   serializer_->address_mapper()->AddMapping(object_, offset);
1442   if (start_new_page) {
1443     sink_->Put(kNewPage, "NewPage");
1444     sink_->PutSection(space, "NewPageSpace");
1445   }
1446
1447   // Serialize the map (first word of the object).
1448   serializer_->SerializeObject(object_->map(), kPlain, kStartOfObject);
1449
1450   // Serialize the rest of the object.
1451   CHECK_EQ(0, bytes_processed_so_far_);
1452   bytes_processed_so_far_ = kPointerSize;
1453   object_->IterateBody(object_->map()->instance_type(), size, this);
1454   OutputRawData(object_->address() + size);
1455 }
1456
1457
1458 void Serializer::ObjectSerializer::VisitPointers(Object** start,
1459                                                  Object** end) {
1460   Object** current = start;
1461   while (current < end) {
1462     while (current < end && (*current)->IsSmi()) current++;
1463     if (current < end) OutputRawData(reinterpret_cast<Address>(current));
1464
1465     while (current < end && !(*current)->IsSmi()) {
1466       HeapObject* current_contents = HeapObject::cast(*current);
1467       int root_index = serializer_->RootIndex(current_contents, kPlain);
1468       // Repeats are not subject to the write barrier so there are only some
1469       // objects that can be used in a repeat encoding.  These are the early
1470       // ones in the root array that are never in new space.
1471       if (current != start &&
1472           root_index != kInvalidRootIndex &&
1473           root_index < kRootArrayNumberOfConstantEncodings &&
1474           current_contents == current[-1]) {
1475         ASSERT(!HEAP->InNewSpace(current_contents));
1476         int repeat_count = 1;
1477         while (current < end - 1 && current[repeat_count] == current_contents) {
1478           repeat_count++;
1479         }
1480         current += repeat_count;
1481         bytes_processed_so_far_ += repeat_count * kPointerSize;
1482         if (repeat_count > kMaxRepeats) {
1483           sink_->Put(kRepeat, "SerializeRepeats");
1484           sink_->PutInt(repeat_count, "SerializeRepeats");
1485         } else {
1486           sink_->Put(CodeForRepeats(repeat_count), "SerializeRepeats");
1487         }
1488       } else {
1489         serializer_->SerializeObject(current_contents, kPlain, kStartOfObject);
1490         bytes_processed_so_far_ += kPointerSize;
1491         current++;
1492       }
1493     }
1494   }
1495 }
1496
1497
1498 void Serializer::ObjectSerializer::VisitEmbeddedPointer(RelocInfo* rinfo) {
1499   Object** current = rinfo->target_object_address();
1500
1501   OutputRawData(rinfo->target_address_address());
1502   HowToCode representation = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
1503   serializer_->SerializeObject(*current, representation, kStartOfObject);
1504   bytes_processed_so_far_ += rinfo->target_address_size();
1505 }
1506
1507
1508 void Serializer::ObjectSerializer::VisitExternalReferences(Address* start,
1509                                                            Address* end) {
1510   Address references_start = reinterpret_cast<Address>(start);
1511   OutputRawData(references_start);
1512
1513   for (Address* current = start; current < end; current++) {
1514     sink_->Put(kExternalReference + kPlain + kStartOfObject, "ExternalRef");
1515     int reference_id = serializer_->EncodeExternalReference(*current);
1516     sink_->PutInt(reference_id, "reference id");
1517   }
1518   bytes_processed_so_far_ += static_cast<int>((end - start) * kPointerSize);
1519 }
1520
1521
1522 void Serializer::ObjectSerializer::VisitExternalReference(RelocInfo* rinfo) {
1523   Address references_start = rinfo->target_address_address();
1524   OutputRawData(references_start);
1525
1526   Address* current = rinfo->target_reference_address();
1527   int representation = rinfo->IsCodedSpecially() ?
1528                        kFromCode + kStartOfObject : kPlain + kStartOfObject;
1529   sink_->Put(kExternalReference + representation, "ExternalRef");
1530   int reference_id = serializer_->EncodeExternalReference(*current);
1531   sink_->PutInt(reference_id, "reference id");
1532   bytes_processed_so_far_ += rinfo->target_address_size();
1533 }
1534
1535
1536 void Serializer::ObjectSerializer::VisitRuntimeEntry(RelocInfo* rinfo) {
1537   Address target_start = rinfo->target_address_address();
1538   OutputRawData(target_start);
1539   Address target = rinfo->target_address();
1540   uint32_t encoding = serializer_->EncodeExternalReference(target);
1541   CHECK(target == NULL ? encoding == 0 : encoding != 0);
1542   int representation;
1543   // Can't use a ternary operator because of gcc.
1544   if (rinfo->IsCodedSpecially()) {
1545     representation = kStartOfObject + kFromCode;
1546   } else {
1547     representation = kStartOfObject + kPlain;
1548   }
1549   sink_->Put(kExternalReference + representation, "ExternalReference");
1550   sink_->PutInt(encoding, "reference id");
1551   bytes_processed_so_far_ += rinfo->target_address_size();
1552 }
1553
1554
1555 void Serializer::ObjectSerializer::VisitCodeTarget(RelocInfo* rinfo) {
1556   CHECK(RelocInfo::IsCodeTarget(rinfo->rmode()));
1557   Address target_start = rinfo->target_address_address();
1558   OutputRawData(target_start);
1559   Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
1560   serializer_->SerializeObject(target, kFromCode, kFirstInstruction);
1561   bytes_processed_so_far_ += rinfo->target_address_size();
1562 }
1563
1564
1565 void Serializer::ObjectSerializer::VisitCodeEntry(Address entry_address) {
1566   Code* target = Code::cast(Code::GetObjectFromEntryAddress(entry_address));
1567   OutputRawData(entry_address);
1568   serializer_->SerializeObject(target, kPlain, kFirstInstruction);
1569   bytes_processed_so_far_ += kPointerSize;
1570 }
1571
1572
1573 void Serializer::ObjectSerializer::VisitGlobalPropertyCell(RelocInfo* rinfo) {
1574   // We shouldn't have any global property cell references in code
1575   // objects in the snapshot.
1576   UNREACHABLE();
1577 }
1578
1579
1580 void Serializer::ObjectSerializer::VisitExternalAsciiString(
1581     v8::String::ExternalAsciiStringResource** resource_pointer) {
1582   Address references_start = reinterpret_cast<Address>(resource_pointer);
1583   OutputRawData(references_start);
1584   for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
1585     Object* source = HEAP->natives_source_cache()->get(i);
1586     if (!source->IsUndefined()) {
1587       ExternalAsciiString* string = ExternalAsciiString::cast(source);
1588       typedef v8::String::ExternalAsciiStringResource Resource;
1589       const Resource* resource = string->resource();
1590       if (resource == *resource_pointer) {
1591         sink_->Put(kNativesStringResource, "NativesStringResource");
1592         sink_->PutSection(i, "NativesStringResourceEnd");
1593         bytes_processed_so_far_ += sizeof(resource);
1594         return;
1595       }
1596     }
1597   }
1598   // One of the strings in the natives cache should match the resource.  We
1599   // can't serialize any other kinds of external strings.
1600   UNREACHABLE();
1601 }
1602
1603
1604 void Serializer::ObjectSerializer::OutputRawData(Address up_to) {
1605   Address object_start = object_->address();
1606   int up_to_offset = static_cast<int>(up_to - object_start);
1607   int skipped = up_to_offset - bytes_processed_so_far_;
1608   // This assert will fail if the reloc info gives us the target_address_address
1609   // locations in a non-ascending order.  Luckily that doesn't happen.
1610   ASSERT(skipped >= 0);
1611   if (skipped != 0) {
1612     Address base = object_start + bytes_processed_so_far_;
1613 #define RAW_CASE(index, length)                                                \
1614     if (skipped == length) {                                                   \
1615       sink_->PutSection(kRawData + index, "RawDataFixed");                     \
1616     } else  /* NOLINT */
1617     COMMON_RAW_LENGTHS(RAW_CASE)
1618 #undef RAW_CASE
1619     {  /* NOLINT */
1620       sink_->Put(kRawData, "RawData");
1621       sink_->PutInt(skipped, "length");
1622     }
1623     for (int i = 0; i < skipped; i++) {
1624       unsigned int data = base[i];
1625       sink_->PutSection(data, "Byte");
1626     }
1627     bytes_processed_so_far_ += skipped;
1628   }
1629 }
1630
1631
1632 int Serializer::SpaceOfObject(HeapObject* object) {
1633   for (int i = FIRST_SPACE; i <= LAST_SPACE; i++) {
1634     AllocationSpace s = static_cast<AllocationSpace>(i);
1635     if (HEAP->InSpace(object, s)) {
1636       if (i == LO_SPACE) {
1637         if (object->IsCode()) {
1638           return kLargeCode;
1639         } else if (object->IsFixedArray()) {
1640           return kLargeFixedArray;
1641         } else {
1642           return kLargeData;
1643         }
1644       }
1645       return i;
1646     }
1647   }
1648   UNREACHABLE();
1649   return 0;
1650 }
1651
1652
1653 int Serializer::SpaceOfAlreadySerializedObject(HeapObject* object) {
1654   for (int i = FIRST_SPACE; i <= LAST_SPACE; i++) {
1655     AllocationSpace s = static_cast<AllocationSpace>(i);
1656     if (HEAP->InSpace(object, s)) {
1657       return i;
1658     }
1659   }
1660   UNREACHABLE();
1661   return 0;
1662 }
1663
1664
1665 int Serializer::Allocate(int space, int size, bool* new_page) {
1666   CHECK(space >= 0 && space < kNumberOfSpaces);
1667   if (SpaceIsLarge(space)) {
1668     // In large object space we merely number the objects instead of trying to
1669     // determine some sort of address.
1670     *new_page = true;
1671     large_object_total_ += size;
1672     return fullness_[LO_SPACE]++;
1673   }
1674   *new_page = false;
1675   if (fullness_[space] == 0) {
1676     *new_page = true;
1677   }
1678   if (SpaceIsPaged(space)) {
1679     // Paged spaces are a little special.  We encode their addresses as if the
1680     // pages were all contiguous and each page were filled up in the range
1681     // 0 - Page::kObjectAreaSize.  In practice the pages may not be contiguous
1682     // and allocation does not start at offset 0 in the page, but this scheme
1683     // means the deserializer can get the page number quickly by shifting the
1684     // serialized address.
1685     CHECK(IsPowerOf2(Page::kPageSize));
1686     int used_in_this_page = (fullness_[space] & (Page::kPageSize - 1));
1687     CHECK(size <= SpaceAreaSize(space));
1688     if (used_in_this_page + size > SpaceAreaSize(space)) {
1689       *new_page = true;
1690       fullness_[space] = RoundUp(fullness_[space], Page::kPageSize);
1691     }
1692   }
1693   int allocation_address = fullness_[space];
1694   fullness_[space] = allocation_address + size;
1695   return allocation_address;
1696 }
1697
1698
1699 int Serializer::SpaceAreaSize(int space) {
1700   if (space == CODE_SPACE) {
1701     return isolate_->memory_allocator()->CodePageAreaSize();
1702   } else {
1703     return Page::kPageSize - Page::kObjectStartOffset;
1704   }
1705 }
1706
1707
1708 } }  // namespace v8::internal