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.
EncodeExternal(TypeCode type,uint16_t id)52 static uint32_t EncodeExternal(TypeCode type, uint16_t id) {
53 return static_cast<uint32_t>(type) << 16 | id;
54 }
55
56
GetInternalPointer(StatsCounter * counter)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
instance(Isolate * isolate)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
AddFromId(TypeCode type,uint16_t id,const char * name,Isolate * isolate)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
Add(Address address,TypeCode type,uint16_t id,const char * name)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
PopulateTable(Isolate * isolate)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 C
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
ExternalReferenceEncoder()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
Encode(Address key) const527 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
NameOfAddress(Address key) const535 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
IndexOf(Address key) const542 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
Put(Address key,int index)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
ExternalReferenceDecoder()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
~ExternalReferenceDecoder()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
Deserializer(SnapshotByteSource * source)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.
Allocate(int space_index,Space * space,int size)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.
GetAddressFromEnd(int 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.
GetAddressFromStart(int 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
Deserialize()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
DeserializePartial(Object ** root)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
~Deserializer()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.
VisitPointers(Object ** start,Object ** end)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.
ReadObject(int space_number,Space * space,Object ** write_back)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
ReadChunk(Object ** current,Object ** limit,int source_space,Address current_object_address)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
PutInt(uintptr_t integer,const char * description)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
Serializer(SnapshotByteSink * sink)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
~Serializer()1131 Serializer::~Serializer() {
1132 delete external_reference_encoder_;
1133 }
1134
1135
SerializeStrongReferences()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
Serialize(Object ** object)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
VisitPointers(Object ** start,Object ** end)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.
Iterate(ObjectVisitor * visitor)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.
SetSnapshotCacheSize(int size)1215 void SerializerDeserializer::SetSnapshotCacheSize(int size) {
1216 Isolate::Current()->set_serialize_partial_snapshot_cache_length(size);
1217 }
1218
1219
PartialSnapshotCacheIndex(HeapObject * heap_object)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
RootIndex(HeapObject * heap_object,HowToCode from)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.
SerializeReferenceToPreviousObject(int space,int address,HowToCode how_to_code,WhereToPoint where_to_point)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
SerializeObject(Object * o,HowToCode how_to_code,WhereToPoint where_to_point)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
SerializeWeakReferences()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
PutRoot(int root_index,HeapObject * object,SerializerDeserializer::HowToCode how_to_code,SerializerDeserializer::WhereToPoint where_to_point)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
SerializeObject(Object * o,HowToCode how_to_code,WhereToPoint where_to_point)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
Serialize()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
VisitPointers(Object ** start,Object ** end)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
VisitEmbeddedPointer(RelocInfo * rinfo)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
VisitExternalReferences(Address * start,Address * end)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
VisitExternalReference(RelocInfo * rinfo)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
VisitRuntimeEntry(RelocInfo * rinfo)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
VisitCodeTarget(RelocInfo * rinfo)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
VisitCodeEntry(Address entry_address)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
VisitGlobalPropertyCell(RelocInfo * rinfo)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
VisitExternalAsciiString(v8::String::ExternalAsciiStringResource ** resource_pointer)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
OutputRawData(Address up_to)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
SpaceOfObject(HeapObject * object)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
SpaceOfAlreadySerializedObject(HeapObject * object)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
Allocate(int space,int size,bool * new_page)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
SpaceAreaSize(int space)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
1709