1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
7 #include "src/accessors.h"
9 #include "src/base/platform/platform.h"
10 #include "src/bootstrapper.h"
11 #include "src/code-stubs.h"
12 #include "src/compiler.h"
13 #include "src/deoptimizer.h"
14 #include "src/execution.h"
15 #include "src/global-handles.h"
16 #include "src/ic/ic.h"
17 #include "src/ic/stub-cache.h"
18 #include "src/natives.h"
19 #include "src/objects.h"
20 #include "src/runtime/runtime.h"
21 #include "src/serialize.h"
22 #include "src/snapshot.h"
23 #include "src/snapshot-source-sink.h"
24 #include "src/v8threads.h"
25 #include "src/version.h"
31 // -----------------------------------------------------------------------------
32 // Coding of external references.
34 // The encoding of an external reference. The type is in the high word.
35 // The id is in the low word.
36 static uint32_t EncodeExternal(TypeCode type, uint16_t id) {
37 return static_cast<uint32_t>(type) << 16 | id;
41 static int* GetInternalPointer(StatsCounter* counter) {
42 // All counters refer to dummy_counter, if deserializing happens without
43 // setting up counters.
44 static int dummy_counter = 0;
45 return counter->Enabled() ? counter->GetInternalPointer() : &dummy_counter;
49 ExternalReferenceTable* ExternalReferenceTable::instance(Isolate* isolate) {
50 ExternalReferenceTable* external_reference_table =
51 isolate->external_reference_table();
52 if (external_reference_table == NULL) {
53 external_reference_table = new ExternalReferenceTable(isolate);
54 isolate->set_external_reference_table(external_reference_table);
56 return external_reference_table;
60 void ExternalReferenceTable::AddFromId(TypeCode type,
67 ExternalReference ref(static_cast<Builtins::CFunctionId>(id), isolate);
68 address = ref.address();
72 ExternalReference ref(static_cast<Builtins::Name>(id), isolate);
73 address = ref.address();
76 case RUNTIME_FUNCTION: {
77 ExternalReference ref(static_cast<Runtime::FunctionId>(id), isolate);
78 address = ref.address();
82 ExternalReference ref(IC_Utility(static_cast<IC::UtilityId>(id)),
84 address = ref.address();
91 Add(address, type, id, name);
95 void ExternalReferenceTable::Add(Address address,
99 DCHECK_NOT_NULL(address);
100 ExternalReferenceEntry entry;
101 entry.address = address;
102 entry.code = EncodeExternal(type, id);
104 DCHECK_NE(0u, entry.code);
105 // Assert that the code is added in ascending order to rule out duplicates.
106 DCHECK((size() == 0) || (code(size() - 1) < entry.code));
108 if (id > max_id_[type]) max_id_[type] = id;
112 void ExternalReferenceTable::PopulateTable(Isolate* isolate) {
113 for (int type_code = 0; type_code < kTypeCodeCount; type_code++) {
114 max_id_[type_code] = 0;
118 Add(ExternalReference::roots_array_start(isolate).address(),
119 "Heap::roots_array_start()");
120 Add(ExternalReference::address_of_stack_limit(isolate).address(),
121 "StackGuard::address_of_jslimit()");
122 Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
123 "StackGuard::address_of_real_jslimit()");
124 Add(ExternalReference::new_space_start(isolate).address(),
125 "Heap::NewSpaceStart()");
126 Add(ExternalReference::new_space_mask(isolate).address(),
127 "Heap::NewSpaceMask()");
128 Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
129 "Heap::NewSpaceAllocationLimitAddress()");
130 Add(ExternalReference::new_space_allocation_top_address(isolate).address(),
131 "Heap::NewSpaceAllocationTopAddress()");
132 Add(ExternalReference::debug_break(isolate).address(), "Debug::Break()");
133 Add(ExternalReference::debug_step_in_fp_address(isolate).address(),
134 "Debug::step_in_fp_addr()");
135 Add(ExternalReference::mod_two_doubles_operation(isolate).address(),
137 // Keyed lookup cache.
138 Add(ExternalReference::keyed_lookup_cache_keys(isolate).address(),
139 "KeyedLookupCache::keys()");
140 Add(ExternalReference::keyed_lookup_cache_field_offsets(isolate).address(),
141 "KeyedLookupCache::field_offsets()");
142 Add(ExternalReference::handle_scope_next_address(isolate).address(),
143 "HandleScope::next");
144 Add(ExternalReference::handle_scope_limit_address(isolate).address(),
145 "HandleScope::limit");
146 Add(ExternalReference::handle_scope_level_address(isolate).address(),
147 "HandleScope::level");
148 Add(ExternalReference::new_deoptimizer_function(isolate).address(),
149 "Deoptimizer::New()");
150 Add(ExternalReference::compute_output_frames_function(isolate).address(),
151 "Deoptimizer::ComputeOutputFrames()");
152 Add(ExternalReference::address_of_min_int().address(),
153 "LDoubleConstant::min_int");
154 Add(ExternalReference::address_of_one_half().address(),
155 "LDoubleConstant::one_half");
156 Add(ExternalReference::isolate_address(isolate).address(), "isolate");
157 Add(ExternalReference::address_of_negative_infinity().address(),
158 "LDoubleConstant::negative_infinity");
159 Add(ExternalReference::power_double_double_function(isolate).address(),
160 "power_double_double_function");
161 Add(ExternalReference::power_double_int_function(isolate).address(),
162 "power_double_int_function");
163 Add(ExternalReference::math_log_double_function(isolate).address(),
165 Add(ExternalReference::store_buffer_top(isolate).address(),
167 Add(ExternalReference::address_of_the_hole_nan().address(), "the_hole_nan");
168 Add(ExternalReference::get_date_field_function(isolate).address(),
170 Add(ExternalReference::date_cache_stamp(isolate).address(),
172 Add(ExternalReference::address_of_pending_message_obj(isolate).address(),
173 "address_of_pending_message_obj");
174 Add(ExternalReference::address_of_has_pending_message(isolate).address(),
175 "address_of_has_pending_message");
176 Add(ExternalReference::address_of_pending_message_script(isolate).address(),
177 "pending_message_script");
178 Add(ExternalReference::get_make_code_young_function(isolate).address(),
179 "Code::MakeCodeYoung");
180 Add(ExternalReference::cpu_features().address(), "cpu_features");
181 Add(ExternalReference(Runtime::kAllocateInNewSpace, isolate).address(),
182 "Runtime::AllocateInNewSpace");
183 Add(ExternalReference(Runtime::kAllocateInTargetSpace, isolate).address(),
184 "Runtime::AllocateInTargetSpace");
185 Add(ExternalReference::old_pointer_space_allocation_top_address(isolate)
187 "Heap::OldPointerSpaceAllocationTopAddress");
188 Add(ExternalReference::old_pointer_space_allocation_limit_address(isolate)
190 "Heap::OldPointerSpaceAllocationLimitAddress");
191 Add(ExternalReference::old_data_space_allocation_top_address(isolate)
193 "Heap::OldDataSpaceAllocationTopAddress");
194 Add(ExternalReference::old_data_space_allocation_limit_address(isolate)
196 "Heap::OldDataSpaceAllocationLimitAddress");
197 Add(ExternalReference::allocation_sites_list_address(isolate).address(),
198 "Heap::allocation_sites_list_address()");
199 Add(ExternalReference::address_of_uint32_bias().address(), "uint32_bias");
200 Add(ExternalReference::get_mark_code_as_executed_function(isolate).address(),
201 "Code::MarkCodeAsExecuted");
202 Add(ExternalReference::is_profiling_address(isolate).address(),
203 "CpuProfiler::is_profiling");
204 Add(ExternalReference::scheduled_exception_address(isolate).address(),
205 "Isolate::scheduled_exception");
206 Add(ExternalReference::invoke_function_callback(isolate).address(),
207 "InvokeFunctionCallback");
208 Add(ExternalReference::invoke_accessor_getter_callback(isolate).address(),
209 "InvokeAccessorGetterCallback");
210 Add(ExternalReference::flush_icache_function(isolate).address(),
211 "CpuFeatures::FlushICache");
212 Add(ExternalReference::log_enter_external_function(isolate).address(),
213 "Logger::EnterExternal");
214 Add(ExternalReference::log_leave_external_function(isolate).address(),
215 "Logger::LeaveExternal");
216 Add(ExternalReference::address_of_minus_one_half().address(),
217 "double_constants.minus_one_half");
218 Add(ExternalReference::stress_deopt_count(isolate).address(),
219 "Isolate::stress_deopt_count_address()");
220 Add(ExternalReference::incremental_marking_record_write_function(isolate)
222 "IncrementalMarking::RecordWriteFromCode");
225 Add(ExternalReference::debug_after_break_target_address(isolate).address(),
226 "Debug::after_break_target_address()");
227 Add(ExternalReference::debug_restarter_frame_function_pointer_address(isolate)
229 "Debug::restarter_frame_function_pointer_address()");
230 Add(ExternalReference::debug_is_active_address(isolate).address(),
231 "Debug::is_active_address()");
233 #ifndef V8_INTERPRETED_REGEXP
234 Add(ExternalReference::re_case_insensitive_compare_uc16(isolate).address(),
235 "NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16()");
236 Add(ExternalReference::re_check_stack_guard_state(isolate).address(),
237 "RegExpMacroAssembler*::CheckStackGuardState()");
238 Add(ExternalReference::re_grow_stack(isolate).address(),
239 "NativeRegExpMacroAssembler::GrowStack()");
240 Add(ExternalReference::re_word_character_map().address(),
241 "NativeRegExpMacroAssembler::word_character_map");
242 Add(ExternalReference::address_of_regexp_stack_limit(isolate).address(),
243 "RegExpStack::limit_address()");
244 Add(ExternalReference::address_of_regexp_stack_memory_address(isolate)
246 "RegExpStack::memory_address()");
247 Add(ExternalReference::address_of_regexp_stack_memory_size(isolate).address(),
248 "RegExpStack::memory_size()");
249 Add(ExternalReference::address_of_static_offsets_vector(isolate).address(),
250 "OffsetsVector::static_offsets_vector");
251 #endif // V8_INTERPRETED_REGEXP
253 // The following populates all of the different type of external references
254 // into the ExternalReferenceTable.
256 // NOTE: This function was originally 100k of code. It has since been
257 // rewritten to be mostly table driven, as the callback macro style tends to
258 // very easily cause code bloat. Please be careful in the future when adding
261 struct RefTableEntry {
267 static const RefTableEntry ref_table[] = {
269 #define DEF_ENTRY_C(name, ignored) \
271 Builtins::c_##name, \
272 "Builtins::" #name },
274 BUILTIN_LIST_C(DEF_ENTRY_C)
277 #define DEF_ENTRY_C(name, ignored) \
280 "Builtins::" #name },
281 #define DEF_ENTRY_A(name, kind, state, extra) DEF_ENTRY_C(name, ignored)
283 BUILTIN_LIST_C(DEF_ENTRY_C)
284 BUILTIN_LIST_A(DEF_ENTRY_A)
285 BUILTIN_LIST_DEBUG_A(DEF_ENTRY_A)
290 #define RUNTIME_ENTRY(name, nargs, ressize) \
291 { RUNTIME_FUNCTION, \
295 RUNTIME_FUNCTION_LIST(RUNTIME_ENTRY)
296 INLINE_OPTIMIZED_FUNCTION_LIST(RUNTIME_ENTRY)
299 #define INLINE_OPTIMIZED_ENTRY(name, nargs, ressize) \
300 { RUNTIME_FUNCTION, \
301 Runtime::kInlineOptimized##name, \
304 INLINE_OPTIMIZED_FUNCTION_LIST(INLINE_OPTIMIZED_ENTRY)
305 #undef INLINE_OPTIMIZED_ENTRY
308 #define IC_ENTRY(name) \
313 IC_UTIL_LIST(IC_ENTRY)
315 }; // end of ref_table[].
317 for (size_t i = 0; i < arraysize(ref_table); ++i) {
318 AddFromId(ref_table[i].type,
325 struct StatsRefTableEntry {
326 StatsCounter* (Counters::*counter)();
331 const StatsRefTableEntry stats_ref_table[] = {
332 #define COUNTER_ENTRY(name, caption) \
334 Counters::k_##name, \
335 "Counters::" #name },
337 STATS_COUNTER_LIST_1(COUNTER_ENTRY)
338 STATS_COUNTER_LIST_2(COUNTER_ENTRY)
340 }; // end of stats_ref_table[].
342 Counters* counters = isolate->counters();
343 for (size_t i = 0; i < arraysize(stats_ref_table); ++i) {
344 Add(reinterpret_cast<Address>(GetInternalPointer(
345 (counters->*(stats_ref_table[i].counter))())),
347 stats_ref_table[i].id,
348 stats_ref_table[i].name);
353 const char* AddressNames[] = {
354 #define BUILD_NAME_LITERAL(CamelName, hacker_name) \
355 "Isolate::" #hacker_name "_address",
356 FOR_EACH_ISOLATE_ADDRESS_NAME(BUILD_NAME_LITERAL)
358 #undef BUILD_NAME_LITERAL
361 for (uint16_t i = 0; i < Isolate::kIsolateAddressCount; ++i) {
362 Add(isolate->get_address_from_id((Isolate::AddressId)i),
363 TOP_ADDRESS, i, AddressNames[i]);
367 #define ACCESSOR_INFO_DECLARATION(name) \
368 Add(FUNCTION_ADDR(&Accessors::name##Getter), ACCESSOR_CODE, \
369 Accessors::k##name##Getter, "Accessors::" #name "Getter"); \
370 Add(FUNCTION_ADDR(&Accessors::name##Setter), ACCESSOR_CODE, \
371 Accessors::k##name##Setter, "Accessors::" #name "Setter");
372 ACCESSOR_INFO_LIST(ACCESSOR_INFO_DECLARATION)
373 #undef ACCESSOR_INFO_DECLARATION
375 StubCache* stub_cache = isolate->stub_cache();
378 Add(stub_cache->key_reference(StubCache::kPrimary).address(),
379 STUB_CACHE_TABLE, 1, "StubCache::primary_->key");
380 Add(stub_cache->value_reference(StubCache::kPrimary).address(),
381 STUB_CACHE_TABLE, 2, "StubCache::primary_->value");
382 Add(stub_cache->map_reference(StubCache::kPrimary).address(),
383 STUB_CACHE_TABLE, 3, "StubCache::primary_->map");
384 Add(stub_cache->key_reference(StubCache::kSecondary).address(),
385 STUB_CACHE_TABLE, 4, "StubCache::secondary_->key");
386 Add(stub_cache->value_reference(StubCache::kSecondary).address(),
387 STUB_CACHE_TABLE, 5, "StubCache::secondary_->value");
388 Add(stub_cache->map_reference(StubCache::kSecondary).address(),
389 STUB_CACHE_TABLE, 6, "StubCache::secondary_->map");
392 Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
393 RUNTIME_ENTRY, 1, "HandleScope::DeleteExtensions");
394 Add(ExternalReference::incremental_marking_record_write_function(isolate)
396 RUNTIME_ENTRY, 2, "IncrementalMarking::RecordWrite");
397 Add(ExternalReference::store_buffer_overflow_function(isolate).address(),
398 RUNTIME_ENTRY, 3, "StoreBuffer::StoreBufferOverflow");
400 // Add a small set of deopt entry addresses to encoder without generating the
401 // deopt table code, which isn't possible at deserialization time.
402 HandleScope scope(isolate);
403 for (int entry = 0; entry < kDeoptTableSerializeEntryCount; ++entry) {
404 Address address = Deoptimizer::GetDeoptimizationEntry(
408 Deoptimizer::CALCULATE_ENTRY_ADDRESS);
409 Add(address, LAZY_DEOPTIMIZATION, entry, "lazy_deopt");
414 ExternalReferenceEncoder::ExternalReferenceEncoder(Isolate* isolate)
415 : encodings_(HashMap::PointersMatch),
417 ExternalReferenceTable* external_references =
418 ExternalReferenceTable::instance(isolate_);
419 for (int i = 0; i < external_references->size(); ++i) {
420 Put(external_references->address(i), i);
425 uint32_t ExternalReferenceEncoder::Encode(Address key) const {
426 int index = IndexOf(key);
427 DCHECK(key == NULL || index >= 0);
429 ExternalReferenceTable::instance(isolate_)->code(index) : 0;
433 const char* ExternalReferenceEncoder::NameOfAddress(Address key) const {
434 int index = IndexOf(key);
435 return index >= 0 ? ExternalReferenceTable::instance(isolate_)->name(index)
440 int ExternalReferenceEncoder::IndexOf(Address key) const {
441 if (key == NULL) return -1;
442 HashMap::Entry* entry =
443 const_cast<HashMap&>(encodings_).Lookup(key, Hash(key), false);
446 : static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
450 void ExternalReferenceEncoder::Put(Address key, int index) {
451 HashMap::Entry* entry = encodings_.Lookup(key, Hash(key), true);
452 entry->value = reinterpret_cast<void*>(index);
456 ExternalReferenceDecoder::ExternalReferenceDecoder(Isolate* isolate)
457 : encodings_(NewArray<Address*>(kTypeCodeCount)),
459 ExternalReferenceTable* external_references =
460 ExternalReferenceTable::instance(isolate_);
461 for (int type = kFirstTypeCode; type < kTypeCodeCount; ++type) {
462 int max = external_references->max_id(type) + 1;
463 encodings_[type] = NewArray<Address>(max + 1);
465 for (int i = 0; i < external_references->size(); ++i) {
466 Put(external_references->code(i), external_references->address(i));
471 ExternalReferenceDecoder::~ExternalReferenceDecoder() {
472 for (int type = kFirstTypeCode; type < kTypeCodeCount; ++type) {
473 DeleteArray(encodings_[type]);
475 DeleteArray(encodings_);
479 RootIndexMap::RootIndexMap(Isolate* isolate) {
480 map_ = new HashMap(HashMap::PointersMatch);
481 Object** root_array = isolate->heap()->roots_array_start();
482 for (int i = 0; i < Heap::kStrongRootListLength; i++) {
483 Object* root = root_array[i];
484 if (root->IsHeapObject() && !isolate->heap()->InNewSpace(root)) {
485 HeapObject* heap_object = HeapObject::cast(root);
486 if (LookupEntry(map_, heap_object, false) != NULL) {
487 // Some root values are initialized to the empty FixedArray();
488 // Do not add them to the map.
489 // TODO(yangguo): This assert is not true. Some roots like
490 // instanceof_cache_answer can be e.g. null.
491 // DCHECK_EQ(isolate->heap()->empty_fixed_array(), heap_object);
493 SetValue(LookupEntry(map_, heap_object, true), i);
500 class CodeAddressMap: public CodeEventLogger {
502 explicit CodeAddressMap(Isolate* isolate)
503 : isolate_(isolate) {
504 isolate->logger()->addCodeEventListener(this);
507 virtual ~CodeAddressMap() {
508 isolate_->logger()->removeCodeEventListener(this);
511 virtual void CodeMoveEvent(Address from, Address to) {
512 address_to_name_map_.Move(from, to);
515 virtual void CodeDisableOptEvent(Code* code, SharedFunctionInfo* shared) {
518 virtual void CodeDeleteEvent(Address from) {
519 address_to_name_map_.Remove(from);
522 const char* Lookup(Address address) {
523 return address_to_name_map_.Lookup(address);
529 NameMap() : impl_(HashMap::PointersMatch) {}
532 for (HashMap::Entry* p = impl_.Start(); p != NULL; p = impl_.Next(p)) {
533 DeleteArray(static_cast<const char*>(p->value));
537 void Insert(Address code_address, const char* name, int name_size) {
538 HashMap::Entry* entry = FindOrCreateEntry(code_address);
539 if (entry->value == NULL) {
540 entry->value = CopyName(name, name_size);
544 const char* Lookup(Address code_address) {
545 HashMap::Entry* entry = FindEntry(code_address);
546 return (entry != NULL) ? static_cast<const char*>(entry->value) : NULL;
549 void Remove(Address code_address) {
550 HashMap::Entry* entry = FindEntry(code_address);
552 DeleteArray(static_cast<char*>(entry->value));
557 void Move(Address from, Address to) {
558 if (from == to) return;
559 HashMap::Entry* from_entry = FindEntry(from);
560 DCHECK(from_entry != NULL);
561 void* value = from_entry->value;
562 RemoveEntry(from_entry);
563 HashMap::Entry* to_entry = FindOrCreateEntry(to);
564 DCHECK(to_entry->value == NULL);
565 to_entry->value = value;
569 static char* CopyName(const char* name, int name_size) {
570 char* result = NewArray<char>(name_size + 1);
571 for (int i = 0; i < name_size; ++i) {
573 if (c == '\0') c = ' ';
576 result[name_size] = '\0';
580 HashMap::Entry* FindOrCreateEntry(Address code_address) {
581 return impl_.Lookup(code_address, ComputePointerHash(code_address), true);
584 HashMap::Entry* FindEntry(Address code_address) {
585 return impl_.Lookup(code_address,
586 ComputePointerHash(code_address),
590 void RemoveEntry(HashMap::Entry* entry) {
591 impl_.Remove(entry->key, entry->hash);
596 DISALLOW_COPY_AND_ASSIGN(NameMap);
599 virtual void LogRecordedBuffer(Code* code,
603 address_to_name_map_.Insert(code->address(), name, length);
606 NameMap address_to_name_map_;
611 void Deserializer::DecodeReservation(
612 Vector<const SerializedData::Reservation> res) {
613 DCHECK_EQ(0, reservations_[NEW_SPACE].length());
614 STATIC_ASSERT(NEW_SPACE == 0);
615 int current_space = NEW_SPACE;
616 for (int i = 0; i < res.length(); i++) {
617 SerializedData::Reservation r(0);
618 memcpy(&r, res.start() + i, sizeof(r));
619 reservations_[current_space].Add({r.chunk_size(), NULL, NULL});
620 if (r.is_last()) current_space++;
622 DCHECK_EQ(kNumberOfSpaces, current_space);
623 for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) current_chunk_[i] = 0;
627 void Deserializer::FlushICacheForNewCodeObjects() {
628 PageIterator it(isolate_->heap()->code_space());
629 while (it.has_next()) {
631 CpuFeatures::FlushICache(p->area_start(), p->area_end() - p->area_start());
636 bool Deserializer::ReserveSpace() {
638 for (int i = NEW_SPACE; i < kNumberOfSpaces; ++i) {
639 CHECK(reservations_[i].length() > 0);
642 if (!isolate_->heap()->ReserveSpace(reservations_)) return false;
643 for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
644 high_water_[i] = reservations_[i][0].start;
650 void Deserializer::Initialize(Isolate* isolate) {
651 DCHECK_NULL(isolate_);
652 DCHECK_NOT_NULL(isolate);
654 DCHECK_NULL(external_reference_decoder_);
655 external_reference_decoder_ = new ExternalReferenceDecoder(isolate);
659 void Deserializer::Deserialize(Isolate* isolate) {
661 if (!ReserveSpace()) V8::FatalProcessOutOfMemory("deserializing context");
662 // No active threads.
663 DCHECK_NULL(isolate_->thread_manager()->FirstThreadStateInUse());
664 // No active handles.
665 DCHECK(isolate_->handle_scope_implementer()->blocks()->is_empty());
666 isolate_->heap()->IterateSmiRoots(this);
667 isolate_->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
668 isolate_->heap()->RepairFreeListsAfterDeserialization();
669 isolate_->heap()->IterateWeakRoots(this, VISIT_ALL);
671 isolate_->heap()->set_native_contexts_list(
672 isolate_->heap()->undefined_value());
673 isolate_->heap()->set_array_buffers_list(
674 isolate_->heap()->undefined_value());
676 // The allocation site list is build during root iteration, but if no sites
677 // were encountered then it needs to be initialized to undefined.
678 if (isolate_->heap()->allocation_sites_list() == Smi::FromInt(0)) {
679 isolate_->heap()->set_allocation_sites_list(
680 isolate_->heap()->undefined_value());
683 // Update data pointers to the external strings containing natives sources.
684 for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
685 Object* source = isolate_->heap()->natives_source_cache()->get(i);
686 if (!source->IsUndefined()) {
687 ExternalOneByteString::cast(source)->update_data_cache();
691 FlushICacheForNewCodeObjects();
693 // Issue code events for newly deserialized code objects.
694 LOG_CODE_EVENT(isolate_, LogCodeObjects());
695 LOG_CODE_EVENT(isolate_, LogCompiledFunctions());
699 MaybeHandle<Object> Deserializer::DeserializePartial(
700 Isolate* isolate, Handle<JSGlobalProxy> global_proxy,
701 Handle<FixedArray>* outdated_contexts_out) {
703 if (!ReserveSpace()) {
704 V8::FatalProcessOutOfMemory("deserialize context");
705 return MaybeHandle<Object>();
708 Vector<Handle<Object> > attached_objects = Vector<Handle<Object> >::New(1);
709 attached_objects[kGlobalProxyReference] = global_proxy;
710 SetAttachedObjects(attached_objects);
712 DisallowHeapAllocation no_gc;
713 // Keep track of the code space start and end pointers in case new
714 // code objects were unserialized
715 OldSpace* code_space = isolate_->heap()->code_space();
716 Address start_address = code_space->top();
718 Object* outdated_contexts;
720 VisitPointer(&outdated_contexts);
722 // There's no code deserialized here. If this assert fires
723 // then that's changed and logging should be added to notify
724 // the profiler et al of the new code.
725 CHECK_EQ(start_address, code_space->top());
726 CHECK(outdated_contexts->IsFixedArray());
727 *outdated_contexts_out =
728 Handle<FixedArray>(FixedArray::cast(outdated_contexts), isolate);
729 return Handle<Object>(root, isolate);
733 MaybeHandle<SharedFunctionInfo> Deserializer::DeserializeCode(
736 if (!ReserveSpace()) {
737 return Handle<SharedFunctionInfo>();
739 deserializing_user_code_ = true;
740 DisallowHeapAllocation no_gc;
743 return Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(root));
748 Deserializer::~Deserializer() {
749 // TODO(svenpanne) Re-enable this assertion when v8 initialization is fixed.
750 // DCHECK(source_.AtEOF());
751 if (external_reference_decoder_) {
752 delete external_reference_decoder_;
753 external_reference_decoder_ = NULL;
755 attached_objects_.Dispose();
759 // This is called on the roots. It is the driver of the deserialization
760 // process. It is also called on the body of each function.
761 void Deserializer::VisitPointers(Object** start, Object** end) {
762 // The space must be new space. Any other space would cause ReadChunk to try
763 // to update the remembered using NULL as the address.
764 ReadData(start, end, NEW_SPACE, NULL);
768 void Deserializer::RelinkAllocationSite(AllocationSite* site) {
769 if (isolate_->heap()->allocation_sites_list() == Smi::FromInt(0)) {
770 site->set_weak_next(isolate_->heap()->undefined_value());
772 site->set_weak_next(isolate_->heap()->allocation_sites_list());
774 isolate_->heap()->set_allocation_sites_list(site);
778 // Used to insert a deserialized internalized string into the string table.
779 class StringTableInsertionKey : public HashTableKey {
781 explicit StringTableInsertionKey(String* string)
782 : string_(string), hash_(HashForObject(string)) {
783 DCHECK(string->IsInternalizedString());
786 bool IsMatch(Object* string) OVERRIDE {
787 // We know that all entries in a hash table had their hash keys created.
788 // Use that knowledge to have fast failure.
789 if (hash_ != HashForObject(string)) return false;
790 // We want to compare the content of two internalized strings here.
791 return string_->SlowEquals(String::cast(string));
794 uint32_t Hash() OVERRIDE { return hash_; }
796 uint32_t HashForObject(Object* key) OVERRIDE {
797 return String::cast(key)->Hash();
800 MUST_USE_RESULT virtual Handle<Object> AsHandle(Isolate* isolate)
802 return handle(string_, isolate);
810 HeapObject* Deserializer::ProcessNewObjectFromSerializedCode(HeapObject* obj) {
811 if (obj->IsString()) {
812 String* string = String::cast(obj);
813 // Uninitialize hash field as the hash seed may have changed.
814 string->set_hash_field(String::kEmptyHashField);
815 if (string->IsInternalizedString()) {
816 DisallowHeapAllocation no_gc;
817 HandleScope scope(isolate_);
818 StringTableInsertionKey key(string);
819 String* canonical = *StringTable::LookupKey(isolate_, &key);
820 string->SetForwardedInternalizedString(canonical);
823 } else if (obj->IsScript()) {
824 Script::cast(obj)->set_id(isolate_->heap()->NextScriptId());
830 HeapObject* Deserializer::GetBackReferencedObject(int space) {
832 BackReference back_reference(source_.GetInt());
833 if (space == LO_SPACE) {
834 CHECK(back_reference.chunk_index() == 0);
835 uint32_t index = back_reference.large_object_index();
836 obj = deserialized_large_objects_[index];
838 DCHECK(space < kNumberOfPreallocatedSpaces);
839 uint32_t chunk_index = back_reference.chunk_index();
840 DCHECK_LE(chunk_index, current_chunk_[space]);
841 uint32_t chunk_offset = back_reference.chunk_offset();
842 obj = HeapObject::FromAddress(reservations_[space][chunk_index].start +
845 if (deserializing_user_code() && obj->IsInternalizedString()) {
846 obj = String::cast(obj)->GetForwardedInternalizedString();
848 hot_objects_.Add(obj);
853 // This routine writes the new object into the pointer provided and then
854 // returns true if the new object was in young space and false otherwise.
855 // The reason for this strange interface is that otherwise the object is
856 // written very late, which means the FreeSpace map is not set up by the
857 // time we need to use it to mark the space at the end of a page free.
858 void Deserializer::ReadObject(int space_number, Object** write_back) {
861 int next_int = source_.GetInt();
863 bool double_align = false;
864 #ifndef V8_HOST_ARCH_64_BIT
865 double_align = next_int == kDoubleAlignmentSentinel;
866 if (double_align) next_int = source_.GetInt();
869 DCHECK_NE(kDoubleAlignmentSentinel, next_int);
870 int size = next_int << kObjectAlignmentBits;
871 int reserved_size = size + (double_align ? kPointerSize : 0);
872 address = Allocate(space_number, reserved_size);
873 obj = HeapObject::FromAddress(address);
875 obj = isolate_->heap()->DoubleAlignForDeserialization(obj, reserved_size);
876 address = obj->address();
879 isolate_->heap()->OnAllocationEvent(obj, size);
880 Object** current = reinterpret_cast<Object**>(address);
881 Object** limit = current + (size >> kPointerSizeLog2);
882 if (FLAG_log_snapshot_positions) {
883 LOG(isolate_, SnapshotPositionEvent(address, source_.position()));
885 ReadData(current, limit, space_number, address);
887 // TODO(mvstanton): consider treating the heap()->allocation_sites_list()
888 // as a (weak) root. If this root is relocated correctly,
889 // RelinkAllocationSite() isn't necessary.
890 if (obj->IsAllocationSite()) RelinkAllocationSite(AllocationSite::cast(obj));
892 // Fix up strings from serialized user code.
893 if (deserializing_user_code()) obj = ProcessNewObjectFromSerializedCode(obj);
895 Object* write_back_obj = obj;
896 UnalignedCopy(write_back, &write_back_obj);
899 DCHECK(space_number == CODE_SPACE || space_number == LO_SPACE);
901 DCHECK(space_number != CODE_SPACE);
904 #if V8_TARGET_ARCH_PPC && \
905 (ABI_USES_FUNCTION_DESCRIPTORS || V8_OOL_CONSTANT_POOL)
906 // If we're on a platform that uses function descriptors
907 // these jump tables make use of RelocInfo::INTERNAL_REFERENCE.
908 // As the V8 serialization code doesn't handle that relocation type
909 // we use this to fix up code that has function descriptors.
910 if (space_number == CODE_SPACE) {
911 Code* code = reinterpret_cast<Code*>(HeapObject::FromAddress(address));
912 for (RelocIterator it(code); !it.done(); it.next()) {
913 RelocInfo::Mode rmode = it.rinfo()->rmode();
914 if (rmode == RelocInfo::INTERNAL_REFERENCE) {
915 Assembler::RelocateInternalReference(it.rinfo()->pc(), 0,
916 code->instruction_start());
924 // We know the space requirements before deserialization and can
925 // pre-allocate that reserved space. During deserialization, all we need
926 // to do is to bump up the pointer for each space in the reserved
927 // space. This is also used for fixing back references.
928 // We may have to split up the pre-allocation into several chunks
929 // because it would not fit onto a single page. We do not have to keep
930 // track of when to move to the next chunk. An opcode will signal this.
931 // Since multiple large objects cannot be folded into one large object
932 // space allocation, we have to do an actual allocation when deserializing
933 // each large object. Instead of tracking offset for back references, we
934 // reference large objects by index.
935 Address Deserializer::Allocate(int space_index, int size) {
936 if (space_index == LO_SPACE) {
937 AlwaysAllocateScope scope(isolate_);
938 LargeObjectSpace* lo_space = isolate_->heap()->lo_space();
939 Executability exec = static_cast<Executability>(source_.Get());
940 AllocationResult result = lo_space->AllocateRaw(size, exec);
941 HeapObject* obj = HeapObject::cast(result.ToObjectChecked());
942 deserialized_large_objects_.Add(obj);
943 return obj->address();
945 DCHECK(space_index < kNumberOfPreallocatedSpaces);
946 Address address = high_water_[space_index];
947 DCHECK_NOT_NULL(address);
948 high_water_[space_index] += size;
950 // Assert that the current reserved chunk is still big enough.
951 const Heap::Reservation& reservation = reservations_[space_index];
952 int chunk_index = current_chunk_[space_index];
953 CHECK_LE(high_water_[space_index], reservation[chunk_index].end);
960 void Deserializer::ReadData(Object** current, Object** limit, int source_space,
961 Address current_object_address) {
962 Isolate* const isolate = isolate_;
963 // Write barrier support costs around 1% in startup time. In fact there
964 // are no new space objects in current boot snapshots, so it's not needed,
965 // but that may change.
966 bool write_barrier_needed = (current_object_address != NULL &&
967 source_space != NEW_SPACE &&
968 source_space != CELL_SPACE &&
969 source_space != PROPERTY_CELL_SPACE &&
970 source_space != CODE_SPACE &&
971 source_space != OLD_DATA_SPACE);
972 while (current < limit) {
973 byte data = source_.Get();
975 #define CASE_STATEMENT(where, how, within, space_number) \
976 case where + how + within + space_number: \
977 STATIC_ASSERT((where & ~kPointedToMask) == 0); \
978 STATIC_ASSERT((how & ~kHowToCodeMask) == 0); \
979 STATIC_ASSERT((within & ~kWhereToPointMask) == 0); \
980 STATIC_ASSERT((space_number & ~kSpaceMask) == 0);
982 #define CASE_BODY(where, how, within, space_number_if_any) \
984 bool emit_write_barrier = false; \
985 bool current_was_incremented = false; \
986 int space_number = space_number_if_any == kAnyOldSpace \
987 ? (data & kSpaceMask) \
988 : space_number_if_any; \
989 if (where == kNewObject && how == kPlain && within == kStartOfObject) { \
990 ReadObject(space_number, current); \
991 emit_write_barrier = (space_number == NEW_SPACE); \
993 Object* new_object = NULL; /* May not be a real Object pointer. */ \
994 if (where == kNewObject) { \
995 ReadObject(space_number, &new_object); \
996 } else if (where == kRootArray) { \
997 int root_id = source_.GetInt(); \
998 new_object = isolate->heap()->roots_array_start()[root_id]; \
999 emit_write_barrier = isolate->heap()->InNewSpace(new_object); \
1000 } else if (where == kPartialSnapshotCache) { \
1001 int cache_index = source_.GetInt(); \
1002 new_object = isolate->serialize_partial_snapshot_cache()[cache_index]; \
1003 emit_write_barrier = isolate->heap()->InNewSpace(new_object); \
1004 } else if (where == kExternalReference) { \
1005 int skip = source_.GetInt(); \
1006 current = reinterpret_cast<Object**>( \
1007 reinterpret_cast<Address>(current) + skip); \
1008 int reference_id = source_.GetInt(); \
1009 Address address = external_reference_decoder_->Decode(reference_id); \
1010 new_object = reinterpret_cast<Object*>(address); \
1011 } else if (where == kBackref) { \
1012 emit_write_barrier = (space_number == NEW_SPACE); \
1013 new_object = GetBackReferencedObject(data & kSpaceMask); \
1014 } else if (where == kBuiltin) { \
1015 DCHECK(deserializing_user_code()); \
1016 int builtin_id = source_.GetInt(); \
1017 DCHECK_LE(0, builtin_id); \
1018 DCHECK_LT(builtin_id, Builtins::builtin_count); \
1019 Builtins::Name name = static_cast<Builtins::Name>(builtin_id); \
1020 new_object = isolate->builtins()->builtin(name); \
1021 emit_write_barrier = false; \
1022 } else if (where == kAttachedReference) { \
1023 int index = source_.GetInt(); \
1024 DCHECK(deserializing_user_code() || index == kGlobalProxyReference); \
1025 new_object = *attached_objects_[index]; \
1026 emit_write_barrier = isolate->heap()->InNewSpace(new_object); \
1028 DCHECK(where == kBackrefWithSkip); \
1029 int skip = source_.GetInt(); \
1030 current = reinterpret_cast<Object**>( \
1031 reinterpret_cast<Address>(current) + skip); \
1032 emit_write_barrier = (space_number == NEW_SPACE); \
1033 new_object = GetBackReferencedObject(data & kSpaceMask); \
1035 if (within == kInnerPointer) { \
1036 if (space_number != CODE_SPACE || new_object->IsCode()) { \
1037 Code* new_code_object = reinterpret_cast<Code*>(new_object); \
1039 reinterpret_cast<Object*>(new_code_object->instruction_start()); \
1041 DCHECK(space_number == CODE_SPACE); \
1042 Cell* cell = Cell::cast(new_object); \
1043 new_object = reinterpret_cast<Object*>(cell->ValueAddress()); \
1046 if (how == kFromCode) { \
1047 Address location_of_branch_data = reinterpret_cast<Address>(current); \
1048 Assembler::deserialization_set_special_target_at( \
1049 location_of_branch_data, \
1050 Code::cast(HeapObject::FromAddress(current_object_address)), \
1051 reinterpret_cast<Address>(new_object)); \
1052 location_of_branch_data += Assembler::kSpecialTargetSize; \
1053 current = reinterpret_cast<Object**>(location_of_branch_data); \
1054 current_was_incremented = true; \
1056 UnalignedCopy(current, &new_object); \
1059 if (emit_write_barrier && write_barrier_needed) { \
1060 Address current_address = reinterpret_cast<Address>(current); \
1061 isolate->heap()->RecordWrite( \
1062 current_object_address, \
1063 static_cast<int>(current_address - current_object_address)); \
1065 if (!current_was_incremented) { \
1071 // This generates a case and a body for the new space (which has to do extra
1072 // write barrier handling) and handles the other spaces with 8 fall-through
1073 // cases and one body.
1074 #define ALL_SPACES(where, how, within) \
1075 CASE_STATEMENT(where, how, within, NEW_SPACE) \
1076 CASE_BODY(where, how, within, NEW_SPACE) \
1077 CASE_STATEMENT(where, how, within, OLD_DATA_SPACE) \
1078 CASE_STATEMENT(where, how, within, OLD_POINTER_SPACE) \
1079 CASE_STATEMENT(where, how, within, CODE_SPACE) \
1080 CASE_STATEMENT(where, how, within, MAP_SPACE) \
1081 CASE_STATEMENT(where, how, within, CELL_SPACE) \
1082 CASE_STATEMENT(where, how, within, PROPERTY_CELL_SPACE) \
1083 CASE_STATEMENT(where, how, within, LO_SPACE) \
1084 CASE_BODY(where, how, within, kAnyOldSpace)
1086 #define FOUR_CASES(byte_code) \
1088 case byte_code + 1: \
1089 case byte_code + 2: \
1092 #define SIXTEEN_CASES(byte_code) \
1093 FOUR_CASES(byte_code) \
1094 FOUR_CASES(byte_code + 4) \
1095 FOUR_CASES(byte_code + 8) \
1096 FOUR_CASES(byte_code + 12)
1098 #define COMMON_RAW_LENGTHS(f) \
1131 // We generate 15 cases and bodies that process special tags that combine
1132 // the raw data tag and the length into one byte.
1133 #define RAW_CASE(index) \
1134 case kRawData + index: { \
1135 byte* raw_data_out = reinterpret_cast<byte*>(current); \
1136 source_.CopyRaw(raw_data_out, index* kPointerSize); \
1137 current = reinterpret_cast<Object**>(raw_data_out + index * kPointerSize); \
1140 COMMON_RAW_LENGTHS(RAW_CASE)
1143 // Deserialize a chunk of raw data that doesn't have one of the popular
1146 int size = source_.GetInt();
1147 byte* raw_data_out = reinterpret_cast<byte*>(current);
1148 source_.CopyRaw(raw_data_out, size);
1152 SIXTEEN_CASES(kRootArrayConstants + kNoSkipDistance)
1153 SIXTEEN_CASES(kRootArrayConstants + kNoSkipDistance + 16) {
1154 int root_id = RootArrayConstantFromByteCode(data);
1155 Object* object = isolate->heap()->roots_array_start()[root_id];
1156 DCHECK(!isolate->heap()->InNewSpace(object));
1157 UnalignedCopy(current++, &object);
1161 SIXTEEN_CASES(kRootArrayConstants + kHasSkipDistance)
1162 SIXTEEN_CASES(kRootArrayConstants + kHasSkipDistance + 16) {
1163 int root_id = RootArrayConstantFromByteCode(data);
1164 int skip = source_.GetInt();
1165 current = reinterpret_cast<Object**>(
1166 reinterpret_cast<intptr_t>(current) + skip);
1167 Object* object = isolate->heap()->roots_array_start()[root_id];
1168 DCHECK(!isolate->heap()->InNewSpace(object));
1169 UnalignedCopy(current++, &object);
1173 case kVariableRepeat: {
1174 int repeats = source_.GetInt();
1175 Object* object = current[-1];
1176 DCHECK(!isolate->heap()->InNewSpace(object));
1177 for (int i = 0; i < repeats; i++) UnalignedCopy(current++, &object);
1181 STATIC_ASSERT(kRootArrayNumberOfConstantEncodings ==
1182 Heap::kOldSpaceRoots);
1183 STATIC_ASSERT(kMaxFixedRepeats == 15);
1184 FOUR_CASES(kFixedRepeat)
1185 FOUR_CASES(kFixedRepeat + 4)
1186 FOUR_CASES(kFixedRepeat + 8)
1187 case kFixedRepeat + 12:
1188 case kFixedRepeat + 13:
1189 case kFixedRepeat + 14: {
1190 int repeats = RepeatsForCode(data);
1192 UnalignedCopy(&object, current - 1);
1193 DCHECK(!isolate->heap()->InNewSpace(object));
1194 for (int i = 0; i < repeats; i++) UnalignedCopy(current++, &object);
1198 // Deserialize a new object and write a pointer to it to the current
1200 ALL_SPACES(kNewObject, kPlain, kStartOfObject)
1201 // Support for direct instruction pointers in functions. It's an inner
1202 // pointer because it points at the entry point, not at the start of the
1204 CASE_STATEMENT(kNewObject, kPlain, kInnerPointer, CODE_SPACE)
1205 CASE_BODY(kNewObject, kPlain, kInnerPointer, CODE_SPACE)
1206 // Deserialize a new code object and write a pointer to its first
1207 // instruction to the current code object.
1208 ALL_SPACES(kNewObject, kFromCode, kInnerPointer)
1209 // Find a recently deserialized object using its offset from the current
1210 // allocation point and write a pointer to it to the current object.
1211 ALL_SPACES(kBackref, kPlain, kStartOfObject)
1212 ALL_SPACES(kBackrefWithSkip, kPlain, kStartOfObject)
1213 #if defined(V8_TARGET_ARCH_MIPS) || defined(V8_TARGET_ARCH_MIPS64) || \
1214 defined(V8_TARGET_ARCH_PPC) || V8_OOL_CONSTANT_POOL
1215 // Deserialize a new object from pointer found in code and write
1216 // a pointer to it to the current object. Required only for MIPS, PPC or
1217 // ARM with ool constant pool, and omitted on the other architectures
1218 // because it is fully unrolled and would cause bloat.
1219 ALL_SPACES(kNewObject, kFromCode, kStartOfObject)
1220 // Find a recently deserialized code object using its offset from the
1221 // current allocation point and write a pointer to it to the current
1222 // object. Required only for MIPS, PPC or ARM with ool constant pool.
1223 ALL_SPACES(kBackref, kFromCode, kStartOfObject)
1224 ALL_SPACES(kBackrefWithSkip, kFromCode, kStartOfObject)
1226 // Find a recently deserialized code object using its offset from the
1227 // current allocation point and write a pointer to its first instruction
1228 // to the current code object or the instruction pointer in a function
1230 ALL_SPACES(kBackref, kFromCode, kInnerPointer)
1231 ALL_SPACES(kBackrefWithSkip, kFromCode, kInnerPointer)
1232 ALL_SPACES(kBackref, kPlain, kInnerPointer)
1233 ALL_SPACES(kBackrefWithSkip, kPlain, kInnerPointer)
1234 // Find an object in the roots array and write a pointer to it to the
1236 CASE_STATEMENT(kRootArray, kPlain, kStartOfObject, 0)
1237 CASE_BODY(kRootArray, kPlain, kStartOfObject, 0)
1238 #if defined(V8_TARGET_ARCH_MIPS) || V8_OOL_CONSTANT_POOL || \
1239 defined(V8_TARGET_ARCH_MIPS64) || defined(V8_TARGET_ARCH_PPC)
1240 // Find an object in the roots array and write a pointer to it to in code.
1241 CASE_STATEMENT(kRootArray, kFromCode, kStartOfObject, 0)
1242 CASE_BODY(kRootArray, kFromCode, kStartOfObject, 0)
1244 // Find an object in the partial snapshots cache and write a pointer to it
1245 // to the current object.
1246 CASE_STATEMENT(kPartialSnapshotCache, kPlain, kStartOfObject, 0)
1247 CASE_BODY(kPartialSnapshotCache,
1251 // Find an code entry in the partial snapshots cache and
1252 // write a pointer to it to the current object.
1253 CASE_STATEMENT(kPartialSnapshotCache, kPlain, kInnerPointer, 0)
1254 CASE_BODY(kPartialSnapshotCache,
1258 // Find an external reference and write a pointer to it to the current
1260 CASE_STATEMENT(kExternalReference, kPlain, kStartOfObject, 0)
1261 CASE_BODY(kExternalReference,
1265 // Find an external reference and write a pointer to it in the current
1267 CASE_STATEMENT(kExternalReference, kFromCode, kStartOfObject, 0)
1268 CASE_BODY(kExternalReference,
1272 // Find a builtin and write a pointer to it to the current object.
1273 CASE_STATEMENT(kBuiltin, kPlain, kStartOfObject, 0)
1274 CASE_BODY(kBuiltin, kPlain, kStartOfObject, 0)
1275 CASE_STATEMENT(kBuiltin, kPlain, kInnerPointer, 0)
1276 CASE_BODY(kBuiltin, kPlain, kInnerPointer, 0)
1277 CASE_STATEMENT(kBuiltin, kFromCode, kInnerPointer, 0)
1278 CASE_BODY(kBuiltin, kFromCode, kInnerPointer, 0)
1279 // Find an object in the attached references and write a pointer to it to
1280 // the current object.
1281 CASE_STATEMENT(kAttachedReference, kPlain, kStartOfObject, 0)
1282 CASE_BODY(kAttachedReference, kPlain, kStartOfObject, 0)
1283 CASE_STATEMENT(kAttachedReference, kPlain, kInnerPointer, 0)
1284 CASE_BODY(kAttachedReference, kPlain, kInnerPointer, 0)
1285 CASE_STATEMENT(kAttachedReference, kFromCode, kInnerPointer, 0)
1286 CASE_BODY(kAttachedReference, kFromCode, kInnerPointer, 0)
1288 #undef CASE_STATEMENT
1293 int size = source_.GetInt();
1294 current = reinterpret_cast<Object**>(
1295 reinterpret_cast<intptr_t>(current) + size);
1299 case kNativesStringResource: {
1300 DCHECK(!isolate_->heap()->deserialization_complete());
1301 int index = source_.Get();
1302 Vector<const char> source_vector = Natives::GetScriptSource(index);
1303 NativesExternalStringResource* resource =
1304 new NativesExternalStringResource(source_vector.start(),
1305 source_vector.length());
1306 Object* resource_obj = reinterpret_cast<Object*>(resource);
1307 UnalignedCopy(current++, &resource_obj);
1312 int space = source_.Get();
1313 DCHECK(space < kNumberOfPreallocatedSpaces);
1314 int chunk_index = current_chunk_[space];
1315 const Heap::Reservation& reservation = reservations_[space];
1316 // Make sure the current chunk is indeed exhausted.
1317 CHECK_EQ(reservation[chunk_index].end, high_water_[space]);
1318 // Move to next reserved chunk.
1319 chunk_index = ++current_chunk_[space];
1320 CHECK_LT(chunk_index, reservation.length());
1321 high_water_[space] = reservation[chunk_index].start;
1325 FOUR_CASES(kHotObjectWithSkip)
1326 FOUR_CASES(kHotObjectWithSkip + 4) {
1327 int skip = source_.GetInt();
1328 current = reinterpret_cast<Object**>(
1329 reinterpret_cast<Address>(current) + skip);
1332 FOUR_CASES(kHotObject)
1333 FOUR_CASES(kHotObject + 4) {
1334 int index = data & kHotObjectIndexMask;
1335 Object* hot_object = hot_objects_.Get(index);
1336 UnalignedCopy(current, &hot_object);
1337 if (write_barrier_needed && isolate->heap()->InNewSpace(hot_object)) {
1338 Address current_address = reinterpret_cast<Address>(current);
1339 isolate->heap()->RecordWrite(
1340 current_object_address,
1341 static_cast<int>(current_address - current_object_address));
1347 case kSynchronize: {
1348 // If we get here then that indicates that you have a mismatch between
1349 // the number of GC roots when serializing and deserializing.
1357 CHECK_EQ(limit, current);
1361 Serializer::Serializer(Isolate* isolate, SnapshotByteSink* sink)
1362 : isolate_(isolate),
1364 external_reference_encoder_(new ExternalReferenceEncoder(isolate)),
1365 root_index_map_(isolate),
1366 code_address_map_(NULL),
1367 large_objects_total_size_(0),
1368 seen_large_objects_index_(0) {
1369 // The serializer is meant to be used only to generate initial heap images
1370 // from a context in which there is only one isolate.
1371 for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
1372 pending_chunk_[i] = 0;
1373 max_chunk_size_[i] = static_cast<uint32_t>(
1374 MemoryAllocator::PageAreaSize(static_cast<AllocationSpace>(i)));
1379 Serializer::~Serializer() {
1380 delete external_reference_encoder_;
1381 if (code_address_map_ != NULL) delete code_address_map_;
1385 void StartupSerializer::SerializeStrongReferences() {
1386 Isolate* isolate = this->isolate();
1387 // No active threads.
1388 CHECK_NULL(isolate->thread_manager()->FirstThreadStateInUse());
1389 // No active or weak handles.
1390 CHECK(isolate->handle_scope_implementer()->blocks()->is_empty());
1391 CHECK_EQ(0, isolate->global_handles()->NumberOfWeakHandles());
1392 CHECK_EQ(0, isolate->eternal_handles()->NumberOfHandles());
1393 // We don't support serializing installed extensions.
1394 CHECK(!isolate->has_installed_extensions());
1395 isolate->heap()->IterateSmiRoots(this);
1396 isolate->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
1400 void StartupSerializer::VisitPointers(Object** start, Object** end) {
1401 for (Object** current = start; current < end; current++) {
1402 if (start == isolate()->heap()->roots_array_start()) {
1403 root_index_wave_front_ =
1404 Max(root_index_wave_front_, static_cast<intptr_t>(current - start));
1406 if (ShouldBeSkipped(current)) {
1407 sink_->Put(kSkip, "Skip");
1408 sink_->PutInt(kPointerSize, "SkipOneWord");
1409 } else if ((*current)->IsSmi()) {
1410 sink_->Put(kOnePointerRawData, "Smi");
1411 for (int i = 0; i < kPointerSize; i++) {
1412 sink_->Put(reinterpret_cast<byte*>(current)[i], "Byte");
1415 SerializeObject(HeapObject::cast(*current), kPlain, kStartOfObject, 0);
1421 void PartialSerializer::Serialize(Object** o) {
1422 if ((*o)->IsContext()) {
1423 Context* context = Context::cast(*o);
1424 global_object_ = context->global_object();
1425 back_reference_map()->AddGlobalProxy(context->global_proxy());
1428 SerializeOutdatedContextsAsFixedArray();
1433 void PartialSerializer::SerializeOutdatedContextsAsFixedArray() {
1434 int length = outdated_contexts_.length();
1436 FixedArray* empty = isolate_->heap()->empty_fixed_array();
1437 SerializeObject(empty, kPlain, kStartOfObject, 0);
1439 // Serialize an imaginary fixed array containing outdated contexts.
1440 int size = FixedArray::SizeFor(length);
1441 Allocate(NEW_SPACE, size);
1442 sink_->Put(kNewObject + NEW_SPACE, "emulated FixedArray");
1443 sink_->PutInt(size >> kObjectAlignmentBits, "FixedArray size in words");
1444 Map* map = isolate_->heap()->fixed_array_map();
1445 SerializeObject(map, kPlain, kStartOfObject, 0);
1446 Smi* length_smi = Smi::FromInt(length);
1447 sink_->Put(kOnePointerRawData, "Smi");
1448 for (int i = 0; i < kPointerSize; i++) {
1449 sink_->Put(reinterpret_cast<byte*>(&length_smi)[i], "Byte");
1451 for (int i = 0; i < length; i++) {
1452 BackReference back_ref = outdated_contexts_[i];
1453 DCHECK(BackReferenceIsAlreadyAllocated(back_ref));
1454 sink_->Put(kBackref + back_ref.space(), "BackRef");
1455 sink_->PutInt(back_ref.reference(), "BackRefValue");
1461 bool Serializer::ShouldBeSkipped(Object** current) {
1462 Object** roots = isolate()->heap()->roots_array_start();
1463 return current == &roots[Heap::kStoreBufferTopRootIndex]
1464 || current == &roots[Heap::kStackLimitRootIndex]
1465 || current == &roots[Heap::kRealStackLimitRootIndex];
1469 void Serializer::VisitPointers(Object** start, Object** end) {
1470 for (Object** current = start; current < end; current++) {
1471 if ((*current)->IsSmi()) {
1472 sink_->Put(kOnePointerRawData, "Smi");
1473 for (int i = 0; i < kPointerSize; i++) {
1474 sink_->Put(reinterpret_cast<byte*>(current)[i], "Byte");
1477 SerializeObject(HeapObject::cast(*current), kPlain, kStartOfObject, 0);
1483 void Serializer::EncodeReservations(
1484 List<SerializedData::Reservation>* out) const {
1485 for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
1486 for (int j = 0; j < completed_chunks_[i].length(); j++) {
1487 out->Add(SerializedData::Reservation(completed_chunks_[i][j]));
1490 if (pending_chunk_[i] > 0 || completed_chunks_[i].length() == 0) {
1491 out->Add(SerializedData::Reservation(pending_chunk_[i]));
1493 out->last().mark_as_last();
1496 out->Add(SerializedData::Reservation(large_objects_total_size_));
1497 out->last().mark_as_last();
1501 // This ensures that the partial snapshot cache keeps things alive during GC and
1502 // tracks their movement. When it is called during serialization of the startup
1503 // snapshot nothing happens. When the partial (context) snapshot is created,
1504 // this array is populated with the pointers that the partial snapshot will
1505 // need. As that happens we emit serialized objects to the startup snapshot
1506 // that correspond to the elements of this cache array. On deserialization we
1507 // therefore need to visit the cache array. This fills it up with pointers to
1508 // deserialized objects.
1509 void SerializerDeserializer::Iterate(Isolate* isolate,
1510 ObjectVisitor* visitor) {
1511 if (isolate->serializer_enabled()) return;
1512 for (int i = 0; ; i++) {
1513 if (isolate->serialize_partial_snapshot_cache_length() <= i) {
1514 // Extend the array ready to get a value from the visitor when
1516 isolate->PushToPartialSnapshotCache(Smi::FromInt(0));
1518 Object** cache = isolate->serialize_partial_snapshot_cache();
1519 visitor->VisitPointers(&cache[i], &cache[i + 1]);
1520 // Sentinel is the undefined object, which is a root so it will not normally
1521 // be found in the cache.
1522 if (cache[i] == isolate->heap()->undefined_value()) {
1529 int PartialSerializer::PartialSnapshotCacheIndex(HeapObject* heap_object) {
1530 Isolate* isolate = this->isolate();
1533 i < isolate->serialize_partial_snapshot_cache_length();
1535 Object* entry = isolate->serialize_partial_snapshot_cache()[i];
1536 if (entry == heap_object) return i;
1539 // We didn't find the object in the cache. So we add it to the cache and
1540 // then visit the pointer so that it becomes part of the startup snapshot
1541 // and we can refer to it from the partial snapshot.
1542 int length = isolate->serialize_partial_snapshot_cache_length();
1543 isolate->PushToPartialSnapshotCache(heap_object);
1544 startup_serializer_->VisitPointer(reinterpret_cast<Object**>(&heap_object));
1545 // We don't recurse from the startup snapshot generator into the partial
1546 // snapshot generator.
1547 DCHECK(length == isolate->serialize_partial_snapshot_cache_length() - 1);
1553 bool Serializer::BackReferenceIsAlreadyAllocated(BackReference reference) {
1554 DCHECK(reference.is_valid());
1555 DCHECK(!reference.is_source());
1556 DCHECK(!reference.is_global_proxy());
1557 AllocationSpace space = reference.space();
1558 int chunk_index = reference.chunk_index();
1559 if (space == LO_SPACE) {
1560 return chunk_index == 0 &&
1561 reference.large_object_index() < seen_large_objects_index_;
1562 } else if (chunk_index == completed_chunks_[space].length()) {
1563 return reference.chunk_offset() < pending_chunk_[space];
1565 return chunk_index < completed_chunks_[space].length() &&
1566 reference.chunk_offset() < completed_chunks_[space][chunk_index];
1572 bool Serializer::SerializeKnownObject(HeapObject* obj, HowToCode how_to_code,
1573 WhereToPoint where_to_point, int skip) {
1574 if (how_to_code == kPlain && where_to_point == kStartOfObject) {
1575 // Encode a reference to a hot object by its index in the working set.
1576 int index = hot_objects_.Find(obj);
1577 if (index != HotObjectsList::kNotFound) {
1578 DCHECK(index >= 0 && index <= kMaxHotObjectIndex);
1579 if (FLAG_trace_serializer) {
1580 PrintF(" Encoding hot object %d:", index);
1585 sink_->Put(kHotObjectWithSkip + index, "HotObjectWithSkip");
1586 sink_->PutInt(skip, "HotObjectSkipDistance");
1588 sink_->Put(kHotObject + index, "HotObject");
1593 BackReference back_reference = back_reference_map_.Lookup(obj);
1594 if (back_reference.is_valid()) {
1595 // Encode the location of an already deserialized object in order to write
1596 // its location into a later object. We can encode the location as an
1597 // offset fromthe start of the deserialized objects or as an offset
1598 // backwards from thecurrent allocation pointer.
1599 if (back_reference.is_source()) {
1601 if (FLAG_trace_serializer) PrintF(" Encoding source object\n");
1602 DCHECK(how_to_code == kPlain && where_to_point == kStartOfObject);
1603 sink_->Put(kAttachedReference + kPlain + kStartOfObject, "Source");
1604 sink_->PutInt(kSourceObjectReference, "kSourceObjectReference");
1605 } else if (back_reference.is_global_proxy()) {
1607 if (FLAG_trace_serializer) PrintF(" Encoding global proxy\n");
1608 DCHECK(how_to_code == kPlain && where_to_point == kStartOfObject);
1609 sink_->Put(kAttachedReference + kPlain + kStartOfObject, "Global Proxy");
1610 sink_->PutInt(kGlobalProxyReference, "kGlobalProxyReference");
1612 if (FLAG_trace_serializer) {
1613 PrintF(" Encoding back reference to: ");
1618 AllocationSpace space = back_reference.space();
1620 sink_->Put(kBackref + how_to_code + where_to_point + space, "BackRef");
1622 sink_->Put(kBackrefWithSkip + how_to_code + where_to_point + space,
1624 sink_->PutInt(skip, "BackRefSkipDistance");
1626 DCHECK(BackReferenceIsAlreadyAllocated(back_reference));
1627 sink_->PutInt(back_reference.reference(), "BackRefValue");
1629 hot_objects_.Add(obj);
1637 void StartupSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
1638 WhereToPoint where_to_point, int skip) {
1639 DCHECK(!obj->IsJSFunction());
1641 int root_index = root_index_map_.Lookup(obj);
1642 // We can only encode roots as such if it has already been serialized.
1643 // That applies to root indices below the wave front.
1644 if (root_index != RootIndexMap::kInvalidRootIndex &&
1645 root_index < root_index_wave_front_) {
1646 PutRoot(root_index, obj, how_to_code, where_to_point, skip);
1650 if (SerializeKnownObject(obj, how_to_code, where_to_point, skip)) return;
1654 // Object has not yet been serialized. Serialize it here.
1655 ObjectSerializer object_serializer(this, obj, sink_, how_to_code,
1657 object_serializer.Serialize();
1661 void StartupSerializer::SerializeWeakReferences() {
1662 // This phase comes right after the serialization (of the snapshot).
1663 // After we have done the partial serialization the partial snapshot cache
1664 // will contain some references needed to decode the partial snapshot. We
1665 // add one entry with 'undefined' which is the sentinel that the deserializer
1666 // uses to know it is done deserializing the array.
1667 Object* undefined = isolate()->heap()->undefined_value();
1668 VisitPointer(&undefined);
1669 isolate()->heap()->IterateWeakRoots(this, VISIT_ALL);
1674 void Serializer::PutRoot(int root_index,
1676 SerializerDeserializer::HowToCode how_to_code,
1677 SerializerDeserializer::WhereToPoint where_to_point,
1679 if (FLAG_trace_serializer) {
1680 PrintF(" Encoding root %d:", root_index);
1681 object->ShortPrint();
1685 if (how_to_code == kPlain &&
1686 where_to_point == kStartOfObject &&
1687 root_index < kRootArrayNumberOfConstantEncodings &&
1688 !isolate()->heap()->InNewSpace(object)) {
1690 sink_->Put(kRootArrayConstants + kNoSkipDistance + root_index,
1693 sink_->Put(kRootArrayConstants + kHasSkipDistance + root_index,
1695 sink_->PutInt(skip, "SkipInPutRoot");
1699 sink_->Put(kRootArray + how_to_code + where_to_point, "RootSerialization");
1700 sink_->PutInt(root_index, "root_index");
1705 void PartialSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
1706 WhereToPoint where_to_point, int skip) {
1708 // The code-caches link to context-specific code objects, which
1709 // the startup and context serializes cannot currently handle.
1710 DCHECK(Map::cast(obj)->code_cache() == obj->GetHeap()->empty_fixed_array());
1713 // Replace typed arrays by undefined.
1714 if (obj->IsJSTypedArray()) obj = isolate_->heap()->undefined_value();
1716 int root_index = root_index_map_.Lookup(obj);
1717 if (root_index != RootIndexMap::kInvalidRootIndex) {
1718 PutRoot(root_index, obj, how_to_code, where_to_point, skip);
1722 if (ShouldBeInThePartialSnapshotCache(obj)) {
1725 int cache_index = PartialSnapshotCacheIndex(obj);
1726 sink_->Put(kPartialSnapshotCache + how_to_code + where_to_point,
1727 "PartialSnapshotCache");
1728 sink_->PutInt(cache_index, "partial_snapshot_cache_index");
1732 // Pointers from the partial snapshot to the objects in the startup snapshot
1733 // should go through the root array or through the partial snapshot cache.
1734 // If this is not the case you may have to add something to the root array.
1735 DCHECK(!startup_serializer_->back_reference_map()->Lookup(obj).is_valid());
1736 // All the internalized strings that the partial snapshot needs should be
1737 // either in the root table or in the partial snapshot cache.
1738 DCHECK(!obj->IsInternalizedString());
1740 if (SerializeKnownObject(obj, how_to_code, where_to_point, skip)) return;
1744 // Object has not yet been serialized. Serialize it here.
1745 ObjectSerializer serializer(this, obj, sink_, how_to_code, where_to_point);
1746 serializer.Serialize();
1748 if (obj->IsContext() &&
1749 Context::cast(obj)->global_object() == global_object_) {
1750 // Context refers to the current global object. This reference will
1751 // become outdated after deserialization.
1752 BackReference back_reference = back_reference_map_.Lookup(obj);
1753 DCHECK(back_reference.is_valid());
1754 outdated_contexts_.Add(back_reference);
1759 void Serializer::ObjectSerializer::SerializePrologue(AllocationSpace space,
1760 int size, Map* map) {
1761 if (serializer_->code_address_map_) {
1762 const char* code_name =
1763 serializer_->code_address_map_->Lookup(object_->address());
1764 LOG(serializer_->isolate_,
1765 CodeNameEvent(object_->address(), sink_->Position(), code_name));
1766 LOG(serializer_->isolate_,
1767 SnapshotPositionEvent(object_->address(), sink_->Position()));
1770 BackReference back_reference;
1771 if (space == LO_SPACE) {
1772 sink_->Put(kNewObject + reference_representation_ + space,
1774 sink_->PutInt(size >> kObjectAlignmentBits, "ObjectSizeInWords");
1775 if (object_->IsCode()) {
1776 sink_->Put(EXECUTABLE, "executable large object");
1778 sink_->Put(NOT_EXECUTABLE, "not executable large object");
1780 back_reference = serializer_->AllocateLargeObject(size);
1782 bool needs_double_align = false;
1783 if (object_->NeedsToEnsureDoubleAlignment()) {
1784 // Add wriggle room for double alignment padding.
1785 back_reference = serializer_->Allocate(space, size + kPointerSize);
1786 needs_double_align = true;
1788 back_reference = serializer_->Allocate(space, size);
1790 sink_->Put(kNewObject + reference_representation_ + space, "NewObject");
1791 if (needs_double_align)
1792 sink_->PutInt(kDoubleAlignmentSentinel, "DoubleAlignSentinel");
1793 int encoded_size = size >> kObjectAlignmentBits;
1794 DCHECK_NE(kDoubleAlignmentSentinel, encoded_size);
1795 sink_->PutInt(encoded_size, "ObjectSizeInWords");
1798 // Mark this object as already serialized.
1799 serializer_->back_reference_map()->Add(object_, back_reference);
1801 // Serialize the map (first word of the object).
1802 serializer_->SerializeObject(map, kPlain, kStartOfObject, 0);
1806 void Serializer::ObjectSerializer::SerializeExternalString() {
1807 // Instead of serializing this as an external string, we serialize
1808 // an imaginary sequential string with the same content.
1809 Isolate* isolate = serializer_->isolate();
1810 DCHECK(object_->IsExternalString());
1811 DCHECK(object_->map() != isolate->heap()->native_source_string_map());
1812 ExternalString* string = ExternalString::cast(object_);
1813 int length = string->length();
1816 int allocation_size;
1817 const byte* resource;
1818 // Find the map and size for the imaginary sequential string.
1819 bool internalized = object_->IsInternalizedString();
1820 if (object_->IsExternalOneByteString()) {
1821 map = internalized ? isolate->heap()->one_byte_internalized_string_map()
1822 : isolate->heap()->one_byte_string_map();
1823 allocation_size = SeqOneByteString::SizeFor(length);
1824 content_size = length * kCharSize;
1825 resource = reinterpret_cast<const byte*>(
1826 ExternalOneByteString::cast(string)->resource()->data());
1828 map = internalized ? isolate->heap()->internalized_string_map()
1829 : isolate->heap()->string_map();
1830 allocation_size = SeqTwoByteString::SizeFor(length);
1831 content_size = length * kShortSize;
1832 resource = reinterpret_cast<const byte*>(
1833 ExternalTwoByteString::cast(string)->resource()->data());
1836 AllocationSpace space = (allocation_size > Page::kMaxRegularHeapObjectSize)
1839 SerializePrologue(space, allocation_size, map);
1841 // Output the rest of the imaginary string.
1842 int bytes_to_output = allocation_size - HeapObject::kHeaderSize;
1844 // Output raw data header. Do not bother with common raw length cases here.
1845 sink_->Put(kRawData, "RawDataForString");
1846 sink_->PutInt(bytes_to_output, "length");
1848 // Serialize string header (except for map).
1849 Address string_start = string->address();
1850 for (int i = HeapObject::kHeaderSize; i < SeqString::kHeaderSize; i++) {
1851 sink_->PutSection(string_start[i], "StringHeader");
1854 // Serialize string content.
1855 sink_->PutRaw(resource, content_size, "StringContent");
1857 // Since the allocation size is rounded up to object alignment, there
1858 // maybe left-over bytes that need to be padded.
1859 int padding_size = allocation_size - SeqString::kHeaderSize - content_size;
1860 DCHECK(0 <= padding_size && padding_size < kObjectAlignment);
1861 for (int i = 0; i < padding_size; i++) sink_->PutSection(0, "StringPadding");
1863 sink_->Put(kSkip, "SkipAfterString");
1864 sink_->PutInt(bytes_to_output, "SkipDistance");
1868 void Serializer::ObjectSerializer::Serialize() {
1869 if (FLAG_trace_serializer) {
1870 PrintF(" Encoding heap object: ");
1871 object_->ShortPrint();
1875 // We cannot serialize typed array objects correctly.
1876 DCHECK(!object_->IsJSTypedArray());
1878 if (object_->IsScript()) {
1879 // Clear cached line ends.
1880 Object* undefined = serializer_->isolate()->heap()->undefined_value();
1881 Script::cast(object_)->set_line_ends(undefined);
1884 if (object_->IsExternalString()) {
1885 Heap* heap = serializer_->isolate()->heap();
1886 if (object_->map() != heap->native_source_string_map()) {
1887 // Usually we cannot recreate resources for external strings. To work
1888 // around this, external strings are serialized to look like ordinary
1889 // sequential strings.
1890 // The exception are native source code strings, since we can recreate
1891 // their resources. In that case we fall through and leave it to
1892 // VisitExternalOneByteString further down.
1893 SerializeExternalString();
1898 int size = object_->Size();
1899 Map* map = object_->map();
1900 SerializePrologue(Serializer::SpaceOfObject(object_), size, map);
1902 // Serialize the rest of the object.
1903 CHECK_EQ(0, bytes_processed_so_far_);
1904 bytes_processed_so_far_ = kPointerSize;
1906 object_->IterateBody(map->instance_type(), size, this);
1907 OutputRawData(object_->address() + size);
1911 void Serializer::ObjectSerializer::VisitPointers(Object** start,
1913 Object** current = start;
1914 while (current < end) {
1915 while (current < end && (*current)->IsSmi()) current++;
1916 if (current < end) OutputRawData(reinterpret_cast<Address>(current));
1918 while (current < end && !(*current)->IsSmi()) {
1919 HeapObject* current_contents = HeapObject::cast(*current);
1920 int root_index = serializer_->root_index_map()->Lookup(current_contents);
1921 // Repeats are not subject to the write barrier so we can only use
1922 // immortal immovable root members. They are never in new space.
1923 if (current != start && root_index != RootIndexMap::kInvalidRootIndex &&
1924 Heap::RootIsImmortalImmovable(root_index) &&
1925 current_contents == current[-1]) {
1926 DCHECK(!serializer_->isolate()->heap()->InNewSpace(current_contents));
1927 int repeat_count = 1;
1928 while (¤t[repeat_count] < end - 1 &&
1929 current[repeat_count] == current_contents) {
1932 current += repeat_count;
1933 bytes_processed_so_far_ += repeat_count * kPointerSize;
1934 if (repeat_count > kMaxFixedRepeats) {
1935 sink_->Put(kVariableRepeat, "SerializeRepeats");
1936 sink_->PutInt(repeat_count, "SerializeRepeats");
1938 sink_->Put(CodeForRepeats(repeat_count), "SerializeRepeats");
1941 serializer_->SerializeObject(
1942 current_contents, kPlain, kStartOfObject, 0);
1943 bytes_processed_so_far_ += kPointerSize;
1951 void Serializer::ObjectSerializer::VisitEmbeddedPointer(RelocInfo* rinfo) {
1952 // Out-of-line constant pool entries will be visited by the ConstantPoolArray.
1953 if (FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool()) return;
1955 int skip = OutputRawData(rinfo->target_address_address(),
1956 kCanReturnSkipInsteadOfSkipping);
1957 HowToCode how_to_code = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
1958 Object* object = rinfo->target_object();
1959 serializer_->SerializeObject(HeapObject::cast(object), how_to_code,
1960 kStartOfObject, skip);
1961 bytes_processed_so_far_ += rinfo->target_address_size();
1965 void Serializer::ObjectSerializer::VisitExternalReference(Address* p) {
1966 int skip = OutputRawData(reinterpret_cast<Address>(p),
1967 kCanReturnSkipInsteadOfSkipping);
1968 sink_->Put(kExternalReference + kPlain + kStartOfObject, "ExternalRef");
1969 sink_->PutInt(skip, "SkipB4ExternalRef");
1970 Address target = *p;
1971 sink_->PutInt(serializer_->EncodeExternalReference(target), "reference id");
1972 bytes_processed_so_far_ += kPointerSize;
1976 void Serializer::ObjectSerializer::VisitExternalReference(RelocInfo* rinfo) {
1977 int skip = OutputRawData(rinfo->target_address_address(),
1978 kCanReturnSkipInsteadOfSkipping);
1979 HowToCode how_to_code = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
1980 sink_->Put(kExternalReference + how_to_code + kStartOfObject, "ExternalRef");
1981 sink_->PutInt(skip, "SkipB4ExternalRef");
1982 Address target = rinfo->target_reference();
1983 sink_->PutInt(serializer_->EncodeExternalReference(target), "reference id");
1984 bytes_processed_so_far_ += rinfo->target_address_size();
1988 void Serializer::ObjectSerializer::VisitRuntimeEntry(RelocInfo* rinfo) {
1989 int skip = OutputRawData(rinfo->target_address_address(),
1990 kCanReturnSkipInsteadOfSkipping);
1991 HowToCode how_to_code = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
1992 sink_->Put(kExternalReference + how_to_code + kStartOfObject, "ExternalRef");
1993 sink_->PutInt(skip, "SkipB4ExternalRef");
1994 Address target = rinfo->target_address();
1995 sink_->PutInt(serializer_->EncodeExternalReference(target), "reference id");
1996 bytes_processed_so_far_ += rinfo->target_address_size();
2000 void Serializer::ObjectSerializer::VisitCodeTarget(RelocInfo* rinfo) {
2001 // Out-of-line constant pool entries will be visited by the ConstantPoolArray.
2002 if (FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool()) return;
2004 int skip = OutputRawData(rinfo->target_address_address(),
2005 kCanReturnSkipInsteadOfSkipping);
2006 Code* object = Code::GetCodeFromTargetAddress(rinfo->target_address());
2007 serializer_->SerializeObject(object, kFromCode, kInnerPointer, skip);
2008 bytes_processed_so_far_ += rinfo->target_address_size();
2012 void Serializer::ObjectSerializer::VisitCodeEntry(Address entry_address) {
2013 int skip = OutputRawData(entry_address, kCanReturnSkipInsteadOfSkipping);
2014 Code* object = Code::cast(Code::GetObjectFromEntryAddress(entry_address));
2015 serializer_->SerializeObject(object, kPlain, kInnerPointer, skip);
2016 bytes_processed_so_far_ += kPointerSize;
2020 void Serializer::ObjectSerializer::VisitCell(RelocInfo* rinfo) {
2021 // Out-of-line constant pool entries will be visited by the ConstantPoolArray.
2022 if (FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool()) return;
2024 int skip = OutputRawData(rinfo->pc(), kCanReturnSkipInsteadOfSkipping);
2025 Cell* object = Cell::cast(rinfo->target_cell());
2026 serializer_->SerializeObject(object, kPlain, kInnerPointer, skip);
2027 bytes_processed_so_far_ += kPointerSize;
2031 void Serializer::ObjectSerializer::VisitExternalOneByteString(
2032 v8::String::ExternalOneByteStringResource** resource_pointer) {
2033 Address references_start = reinterpret_cast<Address>(resource_pointer);
2034 OutputRawData(references_start);
2035 for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
2037 serializer_->isolate()->heap()->natives_source_cache()->get(i);
2038 if (!source->IsUndefined()) {
2039 ExternalOneByteString* string = ExternalOneByteString::cast(source);
2040 typedef v8::String::ExternalOneByteStringResource Resource;
2041 const Resource* resource = string->resource();
2042 if (resource == *resource_pointer) {
2043 sink_->Put(kNativesStringResource, "NativesStringResource");
2044 sink_->PutSection(i, "NativesStringResourceEnd");
2045 bytes_processed_so_far_ += sizeof(resource);
2050 // One of the strings in the natives cache should match the resource. We
2051 // don't expect any other kinds of external strings here.
2056 static Code* CloneCodeObject(HeapObject* code) {
2057 Address copy = new byte[code->Size()];
2058 MemCopy(copy, code->address(), code->Size());
2059 return Code::cast(HeapObject::FromAddress(copy));
2063 static void WipeOutRelocations(Code* code) {
2065 RelocInfo::kCodeTargetMask |
2066 RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
2067 RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
2068 RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY);
2069 for (RelocIterator it(code, mode_mask); !it.done(); it.next()) {
2070 if (!(FLAG_enable_ool_constant_pool && it.rinfo()->IsInConstantPool())) {
2071 it.rinfo()->WipeOut();
2077 int Serializer::ObjectSerializer::OutputRawData(
2078 Address up_to, Serializer::ObjectSerializer::ReturnSkip return_skip) {
2079 Address object_start = object_->address();
2080 int base = bytes_processed_so_far_;
2081 int up_to_offset = static_cast<int>(up_to - object_start);
2082 int to_skip = up_to_offset - bytes_processed_so_far_;
2083 int bytes_to_output = to_skip;
2084 bytes_processed_so_far_ += to_skip;
2085 // This assert will fail if the reloc info gives us the target_address_address
2086 // locations in a non-ascending order. Luckily that doesn't happen.
2087 DCHECK(to_skip >= 0);
2088 bool outputting_code = false;
2089 if (to_skip != 0 && code_object_ && !code_has_been_output_) {
2090 // Output the code all at once and fix later.
2091 bytes_to_output = object_->Size() + to_skip - bytes_processed_so_far_;
2092 outputting_code = true;
2093 code_has_been_output_ = true;
2095 if (bytes_to_output != 0 &&
2096 (!code_object_ || outputting_code)) {
2097 #define RAW_CASE(index) \
2098 if (!outputting_code && bytes_to_output == index * kPointerSize && \
2099 index * kPointerSize == to_skip) { \
2100 sink_->PutSection(kRawData + index, "RawDataFixed"); \
2101 to_skip = 0; /* This insn already skips. */ \
2103 COMMON_RAW_LENGTHS(RAW_CASE)
2106 // We always end up here if we are outputting the code of a code object.
2107 sink_->Put(kRawData, "RawData");
2108 sink_->PutInt(bytes_to_output, "length");
2111 // To make snapshots reproducible, we need to wipe out all pointers in code.
2113 Code* code = CloneCodeObject(object_);
2114 // Code age headers are not serializable.
2115 code->MakeYoung(serializer_->isolate());
2116 WipeOutRelocations(code);
2117 // We need to wipe out the header fields *after* wiping out the
2118 // relocations, because some of these fields are needed for the latter.
2119 code->WipeOutHeader();
2120 object_start = code->address();
2123 const char* description = code_object_ ? "Code" : "Byte";
2124 #ifdef MEMORY_SANITIZER
2125 // Object sizes are usually rounded up with uninitialized padding space.
2126 MSAN_MEMORY_IS_INITIALIZED(object_start + base, bytes_to_output);
2127 #endif // MEMORY_SANITIZER
2128 sink_->PutRaw(object_start + base, bytes_to_output, description);
2129 if (code_object_) delete[] object_start;
2131 if (to_skip != 0 && return_skip == kIgnoringReturn) {
2132 sink_->Put(kSkip, "Skip");
2133 sink_->PutInt(to_skip, "SkipDistance");
2140 AllocationSpace Serializer::SpaceOfObject(HeapObject* object) {
2141 for (int i = FIRST_SPACE; i <= LAST_SPACE; i++) {
2142 AllocationSpace s = static_cast<AllocationSpace>(i);
2143 if (object->GetHeap()->InSpace(object, s)) {
2144 DCHECK(i < kNumberOfSpaces);
2153 BackReference Serializer::AllocateLargeObject(int size) {
2154 // Large objects are allocated one-by-one when deserializing. We do not
2155 // have to keep track of multiple chunks.
2156 large_objects_total_size_ += size;
2157 return BackReference::LargeObjectReference(seen_large_objects_index_++);
2161 BackReference Serializer::Allocate(AllocationSpace space, int size) {
2162 DCHECK(space >= 0 && space < kNumberOfPreallocatedSpaces);
2163 DCHECK(size > 0 && size <= static_cast<int>(max_chunk_size(space)));
2164 uint32_t new_chunk_size = pending_chunk_[space] + size;
2165 if (new_chunk_size > max_chunk_size(space)) {
2166 // The new chunk size would not fit onto a single page. Complete the
2167 // current chunk and start a new one.
2168 sink_->Put(kNextChunk, "NextChunk");
2169 sink_->Put(space, "NextChunkSpace");
2170 completed_chunks_[space].Add(pending_chunk_[space]);
2171 DCHECK_LE(completed_chunks_[space].length(), BackReference::kMaxChunkIndex);
2172 pending_chunk_[space] = 0;
2173 new_chunk_size = size;
2175 uint32_t offset = pending_chunk_[space];
2176 pending_chunk_[space] = new_chunk_size;
2177 return BackReference::Reference(space, completed_chunks_[space].length(),
2182 void Serializer::Pad() {
2183 // The non-branching GetInt will read up to 3 bytes too far, so we need
2184 // to pad the snapshot to make sure we don't read over the end.
2185 for (unsigned i = 0; i < sizeof(int32_t) - 1; i++) {
2186 sink_->Put(kNop, "Padding");
2188 // Pad up to pointer size for checksum.
2189 while (!IsAligned(sink_->Position(), kPointerAlignment)) {
2190 sink_->Put(kNop, "Padding");
2195 void Serializer::InitializeCodeAddressMap() {
2196 isolate_->InitializeLoggingAndCounters();
2197 code_address_map_ = new CodeAddressMap(isolate_);
2201 ScriptData* CodeSerializer::Serialize(Isolate* isolate,
2202 Handle<SharedFunctionInfo> info,
2203 Handle<String> source) {
2204 base::ElapsedTimer timer;
2205 if (FLAG_profile_deserialization) timer.Start();
2206 if (FLAG_trace_serializer) {
2207 PrintF("[Serializing from");
2208 Object* script = info->script();
2209 if (script->IsScript()) Script::cast(script)->name()->ShortPrint();
2213 // Serialize code object.
2214 SnapshotByteSink sink(info->code()->CodeSize() * 2);
2215 CodeSerializer cs(isolate, &sink, *source, info->code());
2216 DisallowHeapAllocation no_gc;
2217 Object** location = Handle<Object>::cast(info).location();
2218 cs.VisitPointer(location);
2221 SerializedCodeData data(sink.data(), cs);
2222 ScriptData* script_data = data.GetScriptData();
2224 if (FLAG_profile_deserialization) {
2225 double ms = timer.Elapsed().InMillisecondsF();
2226 int length = script_data->length();
2227 PrintF("[Serializing to %d bytes took %0.3f ms]\n", length, ms);
2234 void CodeSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
2235 WhereToPoint where_to_point, int skip) {
2236 int root_index = root_index_map_.Lookup(obj);
2237 if (root_index != RootIndexMap::kInvalidRootIndex) {
2238 PutRoot(root_index, obj, how_to_code, where_to_point, skip);
2242 if (SerializeKnownObject(obj, how_to_code, where_to_point, skip)) return;
2246 if (obj->IsCode()) {
2247 Code* code_object = Code::cast(obj);
2248 switch (code_object->kind()) {
2249 case Code::OPTIMIZED_FUNCTION: // No optimized code compiled yet.
2250 case Code::HANDLER: // No handlers patched in yet.
2251 case Code::REGEXP: // No regexp literals initialized yet.
2252 case Code::NUMBER_OF_KINDS: // Pseudo enum value.
2255 SerializeBuiltin(code_object->builtin_index(), how_to_code,
2259 SerializeCodeStub(code_object->stub_key(), how_to_code, where_to_point);
2261 #define IC_KIND_CASE(KIND) case Code::KIND:
2262 IC_KIND_LIST(IC_KIND_CASE)
2264 SerializeIC(code_object, how_to_code, where_to_point);
2266 case Code::FUNCTION:
2267 DCHECK(code_object->has_reloc_info_for_serialization());
2268 // Only serialize the code for the toplevel function unless specified
2269 // by flag. Replace code of inner functions by the lazy compile builtin.
2270 // This is safe, as checked in Compiler::BuildFunctionInfo.
2271 if (code_object != main_code_ && !FLAG_serialize_inner) {
2272 SerializeBuiltin(Builtins::kCompileLazy, how_to_code, where_to_point);
2274 SerializeGeneric(code_object, how_to_code, where_to_point);
2281 // Past this point we should not see any (context-specific) maps anymore.
2282 CHECK(!obj->IsMap());
2283 // There should be no references to the global object embedded.
2284 CHECK(!obj->IsJSGlobalProxy() && !obj->IsGlobalObject());
2285 // There should be no hash table embedded. They would require rehashing.
2286 CHECK(!obj->IsHashTable());
2287 // We expect no instantiated function objects or contexts.
2288 CHECK(!obj->IsJSFunction() && !obj->IsContext());
2290 SerializeGeneric(obj, how_to_code, where_to_point);
2294 void CodeSerializer::SerializeGeneric(HeapObject* heap_object,
2295 HowToCode how_to_code,
2296 WhereToPoint where_to_point) {
2297 if (heap_object->IsInternalizedString()) num_internalized_strings_++;
2299 // Object has not yet been serialized. Serialize it here.
2300 ObjectSerializer serializer(this, heap_object, sink_, how_to_code,
2302 serializer.Serialize();
2306 void CodeSerializer::SerializeBuiltin(int builtin_index, HowToCode how_to_code,
2307 WhereToPoint where_to_point) {
2308 DCHECK((how_to_code == kPlain && where_to_point == kStartOfObject) ||
2309 (how_to_code == kPlain && where_to_point == kInnerPointer) ||
2310 (how_to_code == kFromCode && where_to_point == kInnerPointer));
2311 DCHECK_LT(builtin_index, Builtins::builtin_count);
2312 DCHECK_LE(0, builtin_index);
2314 if (FLAG_trace_serializer) {
2315 PrintF(" Encoding builtin: %s\n",
2316 isolate()->builtins()->name(builtin_index));
2319 sink_->Put(kBuiltin + how_to_code + where_to_point, "Builtin");
2320 sink_->PutInt(builtin_index, "builtin_index");
2324 void CodeSerializer::SerializeCodeStub(uint32_t stub_key, HowToCode how_to_code,
2325 WhereToPoint where_to_point) {
2326 DCHECK((how_to_code == kPlain && where_to_point == kStartOfObject) ||
2327 (how_to_code == kPlain && where_to_point == kInnerPointer) ||
2328 (how_to_code == kFromCode && where_to_point == kInnerPointer));
2329 DCHECK(CodeStub::MajorKeyFromKey(stub_key) != CodeStub::NoCache);
2330 DCHECK(!CodeStub::GetCode(isolate(), stub_key).is_null());
2332 int index = AddCodeStubKey(stub_key) + kCodeStubsBaseIndex;
2334 if (FLAG_trace_serializer) {
2335 PrintF(" Encoding code stub %s as %d\n",
2336 CodeStub::MajorName(CodeStub::MajorKeyFromKey(stub_key), false),
2340 sink_->Put(kAttachedReference + how_to_code + where_to_point, "CodeStub");
2341 sink_->PutInt(index, "CodeStub key");
2345 void CodeSerializer::SerializeIC(Code* ic, HowToCode how_to_code,
2346 WhereToPoint where_to_point) {
2347 // The IC may be implemented as a stub.
2348 uint32_t stub_key = ic->stub_key();
2349 if (stub_key != CodeStub::NoCacheKey()) {
2350 if (FLAG_trace_serializer) {
2351 PrintF(" %s is a code stub\n", Code::Kind2String(ic->kind()));
2353 SerializeCodeStub(stub_key, how_to_code, where_to_point);
2356 // The IC may be implemented as builtin. Only real builtins have an
2357 // actual builtin_index value attached (otherwise it's just garbage).
2358 // Compare to make sure we are really dealing with a builtin.
2359 int builtin_index = ic->builtin_index();
2360 if (builtin_index < Builtins::builtin_count) {
2361 Builtins::Name name = static_cast<Builtins::Name>(builtin_index);
2362 Code* builtin = isolate()->builtins()->builtin(name);
2363 if (builtin == ic) {
2364 if (FLAG_trace_serializer) {
2365 PrintF(" %s is a builtin\n", Code::Kind2String(ic->kind()));
2367 DCHECK(ic->kind() == Code::KEYED_LOAD_IC ||
2368 ic->kind() == Code::KEYED_STORE_IC);
2369 SerializeBuiltin(builtin_index, how_to_code, where_to_point);
2373 // The IC may also just be a piece of code kept in the non_monomorphic_cache.
2374 // In that case, just serialize as a normal code object.
2375 if (FLAG_trace_serializer) {
2376 PrintF(" %s has no special handling\n", Code::Kind2String(ic->kind()));
2378 DCHECK(ic->kind() == Code::LOAD_IC || ic->kind() == Code::STORE_IC);
2379 SerializeGeneric(ic, how_to_code, where_to_point);
2383 int CodeSerializer::AddCodeStubKey(uint32_t stub_key) {
2384 // TODO(yangguo) Maybe we need a hash table for a faster lookup than O(n^2).
2386 while (index < stub_keys_.length()) {
2387 if (stub_keys_[index] == stub_key) return index;
2390 stub_keys_.Add(stub_key);
2395 MaybeHandle<SharedFunctionInfo> CodeSerializer::Deserialize(
2396 Isolate* isolate, ScriptData* cached_data, Handle<String> source) {
2397 base::ElapsedTimer timer;
2398 if (FLAG_profile_deserialization) timer.Start();
2400 HandleScope scope(isolate);
2402 SmartPointer<SerializedCodeData> scd(
2403 SerializedCodeData::FromCachedData(cached_data, *source));
2404 if (scd.is_empty()) {
2405 if (FLAG_profile_deserialization) PrintF("[Cached code failed check]\n");
2406 DCHECK(cached_data->rejected());
2407 return MaybeHandle<SharedFunctionInfo>();
2410 // Eagerly expand string table to avoid allocations during deserialization.
2411 StringTable::EnsureCapacityForDeserialization(isolate,
2412 scd->NumInternalizedStrings());
2414 // Prepare and register list of attached objects.
2415 Vector<const uint32_t> code_stub_keys = scd->CodeStubKeys();
2416 Vector<Handle<Object> > attached_objects = Vector<Handle<Object> >::New(
2417 code_stub_keys.length() + kCodeStubsBaseIndex);
2418 attached_objects[kSourceObjectIndex] = source;
2419 for (int i = 0; i < code_stub_keys.length(); i++) {
2420 attached_objects[i + kCodeStubsBaseIndex] =
2421 CodeStub::GetCode(isolate, code_stub_keys[i]).ToHandleChecked();
2424 Deserializer deserializer(scd.get());
2425 deserializer.SetAttachedObjects(attached_objects);
2428 Handle<SharedFunctionInfo> result;
2429 if (!deserializer.DeserializeCode(isolate).ToHandle(&result)) {
2430 // Deserializing may fail if the reservations cannot be fulfilled.
2431 if (FLAG_profile_deserialization) PrintF("[Deserializing failed]\n");
2432 return MaybeHandle<SharedFunctionInfo>();
2434 deserializer.FlushICacheForNewCodeObjects();
2436 if (FLAG_profile_deserialization) {
2437 double ms = timer.Elapsed().InMillisecondsF();
2438 int length = cached_data->length();
2439 PrintF("[Deserializing from %d bytes took %0.3f ms]\n", length, ms);
2441 result->set_deserialized(true);
2443 if (isolate->logger()->is_logging_code_events() ||
2444 isolate->cpu_profiler()->is_profiling()) {
2445 String* name = isolate->heap()->empty_string();
2446 if (result->script()->IsScript()) {
2447 Script* script = Script::cast(result->script());
2448 if (script->name()->IsString()) name = String::cast(script->name());
2450 isolate->logger()->CodeCreateEvent(Logger::SCRIPT_TAG, result->code(),
2451 *result, NULL, name);
2454 return scope.CloseAndEscape(result);
2458 void SerializedData::AllocateData(int size) {
2459 DCHECK(!owns_data_);
2460 data_ = NewArray<byte>(size);
2463 DCHECK(IsAligned(reinterpret_cast<intptr_t>(data_), kPointerAlignment));
2467 SnapshotData::SnapshotData(const Serializer& ser) {
2468 DisallowHeapAllocation no_gc;
2469 List<Reservation> reservations;
2470 ser.EncodeReservations(&reservations);
2471 const List<byte>& payload = ser.sink()->data();
2474 int reservation_size = reservations.length() * kInt32Size;
2475 int size = kHeaderSize + reservation_size + payload.length();
2477 // Allocate backing store and create result data.
2480 // Set header values.
2481 SetHeaderValue(kCheckSumOffset, Version::Hash());
2482 SetHeaderValue(kNumReservationsOffset, reservations.length());
2483 SetHeaderValue(kPayloadLengthOffset, payload.length());
2485 // Copy reservation chunk sizes.
2486 CopyBytes(data_ + kHeaderSize, reinterpret_cast<byte*>(reservations.begin()),
2489 // Copy serialized data.
2490 CopyBytes(data_ + kHeaderSize + reservation_size, payload.begin(),
2491 static_cast<size_t>(payload.length()));
2495 bool SnapshotData::IsSane() {
2496 return GetHeaderValue(kCheckSumOffset) == Version::Hash();
2500 Vector<const SerializedData::Reservation> SnapshotData::Reservations() const {
2501 return Vector<const Reservation>(
2502 reinterpret_cast<const Reservation*>(data_ + kHeaderSize),
2503 GetHeaderValue(kNumReservationsOffset));
2507 Vector<const byte> SnapshotData::Payload() const {
2508 int reservations_size = GetHeaderValue(kNumReservationsOffset) * kInt32Size;
2509 const byte* payload = data_ + kHeaderSize + reservations_size;
2510 int length = GetHeaderValue(kPayloadLengthOffset);
2511 DCHECK_EQ(data_ + size_, payload + length);
2512 return Vector<const byte>(payload, length);
2518 explicit Checksum(Vector<const byte> payload) {
2519 // Fletcher's checksum. Modified to reduce 64-bit sums to 32-bit.
2522 const uintptr_t* cur = reinterpret_cast<const uintptr_t*>(payload.start());
2523 DCHECK(IsAligned(payload.length(), kIntptrSize));
2524 const uintptr_t* end = cur + payload.length() / kIntptrSize;
2526 // Unsigned overflow expected and intended.
2530 #if V8_HOST_ARCH_64_BIT
2533 #endif // V8_HOST_ARCH_64_BIT
2534 a_ = static_cast<uint32_t>(a);
2535 b_ = static_cast<uint32_t>(b);
2538 bool Check(uint32_t a, uint32_t b) const { return a == a_ && b == b_; }
2540 uint32_t a() const { return a_; }
2541 uint32_t b() const { return b_; }
2547 DISALLOW_COPY_AND_ASSIGN(Checksum);
2551 SerializedCodeData::SerializedCodeData(const List<byte>& payload,
2552 const CodeSerializer& cs) {
2553 DisallowHeapAllocation no_gc;
2554 const List<uint32_t>* stub_keys = cs.stub_keys();
2556 List<Reservation> reservations;
2557 cs.EncodeReservations(&reservations);
2560 int reservation_size = reservations.length() * kInt32Size;
2561 int num_stub_keys = stub_keys->length();
2562 int stub_keys_size = stub_keys->length() * kInt32Size;
2563 int payload_offset = kHeaderSize + reservation_size + stub_keys_size;
2564 int padded_payload_offset = POINTER_SIZE_ALIGN(payload_offset);
2565 int size = padded_payload_offset + payload.length();
2567 // Allocate backing store and create result data.
2570 // Set header values.
2571 SetHeaderValue(kMagicNumberOffset, kMagicNumber);
2572 SetHeaderValue(kVersionHashOffset, Version::Hash());
2573 SetHeaderValue(kSourceHashOffset, SourceHash(cs.source()));
2574 SetHeaderValue(kCpuFeaturesOffset,
2575 static_cast<uint32_t>(CpuFeatures::SupportedFeatures()));
2576 SetHeaderValue(kFlagHashOffset, FlagList::Hash());
2577 SetHeaderValue(kNumInternalizedStringsOffset, cs.num_internalized_strings());
2578 SetHeaderValue(kNumReservationsOffset, reservations.length());
2579 SetHeaderValue(kNumCodeStubKeysOffset, num_stub_keys);
2580 SetHeaderValue(kPayloadLengthOffset, payload.length());
2582 Checksum checksum(payload.ToConstVector());
2583 SetHeaderValue(kChecksum1Offset, checksum.a());
2584 SetHeaderValue(kChecksum2Offset, checksum.b());
2586 // Copy reservation chunk sizes.
2587 CopyBytes(data_ + kHeaderSize, reinterpret_cast<byte*>(reservations.begin()),
2590 // Copy code stub keys.
2591 CopyBytes(data_ + kHeaderSize + reservation_size,
2592 reinterpret_cast<byte*>(stub_keys->begin()), stub_keys_size);
2594 memset(data_ + payload_offset, 0, padded_payload_offset - payload_offset);
2596 // Copy serialized data.
2597 CopyBytes(data_ + padded_payload_offset, payload.begin(),
2598 static_cast<size_t>(payload.length()));
2602 SerializedCodeData::SanityCheckResult SerializedCodeData::SanityCheck(
2603 String* source) const {
2604 uint32_t magic_number = GetHeaderValue(kMagicNumberOffset);
2605 uint32_t version_hash = GetHeaderValue(kVersionHashOffset);
2606 uint32_t source_hash = GetHeaderValue(kSourceHashOffset);
2607 uint32_t cpu_features = GetHeaderValue(kCpuFeaturesOffset);
2608 uint32_t flags_hash = GetHeaderValue(kFlagHashOffset);
2609 uint32_t c1 = GetHeaderValue(kChecksum1Offset);
2610 uint32_t c2 = GetHeaderValue(kChecksum2Offset);
2611 if (magic_number != kMagicNumber) return MAGIC_NUMBER_MISMATCH;
2612 if (version_hash != Version::Hash()) return VERSION_MISMATCH;
2613 if (source_hash != SourceHash(source)) return SOURCE_MISMATCH;
2614 if (cpu_features != static_cast<uint32_t>(CpuFeatures::SupportedFeatures())) {
2615 return CPU_FEATURES_MISMATCH;
2617 if (flags_hash != FlagList::Hash()) return FLAGS_MISMATCH;
2618 if (!Checksum(Payload()).Check(c1, c2)) return CHECKSUM_MISMATCH;
2619 return CHECK_SUCCESS;
2623 // Return ScriptData object and relinquish ownership over it to the caller.
2624 ScriptData* SerializedCodeData::GetScriptData() {
2626 ScriptData* result = new ScriptData(data_, size_);
2627 result->AcquireDataOwnership();
2634 Vector<const SerializedData::Reservation> SerializedCodeData::Reservations()
2636 return Vector<const Reservation>(
2637 reinterpret_cast<const Reservation*>(data_ + kHeaderSize),
2638 GetHeaderValue(kNumReservationsOffset));
2642 Vector<const byte> SerializedCodeData::Payload() const {
2643 int reservations_size = GetHeaderValue(kNumReservationsOffset) * kInt32Size;
2644 int code_stubs_size = GetHeaderValue(kNumCodeStubKeysOffset) * kInt32Size;
2645 int payload_offset = kHeaderSize + reservations_size + code_stubs_size;
2646 int padded_payload_offset = POINTER_SIZE_ALIGN(payload_offset);
2647 const byte* payload = data_ + padded_payload_offset;
2648 DCHECK(IsAligned(reinterpret_cast<intptr_t>(payload), kPointerAlignment));
2649 int length = GetHeaderValue(kPayloadLengthOffset);
2650 DCHECK_EQ(data_ + size_, payload + length);
2651 return Vector<const byte>(payload, length);
2655 int SerializedCodeData::NumInternalizedStrings() const {
2656 return GetHeaderValue(kNumInternalizedStringsOffset);
2659 Vector<const uint32_t> SerializedCodeData::CodeStubKeys() const {
2660 int reservations_size = GetHeaderValue(kNumReservationsOffset) * kInt32Size;
2661 const byte* start = data_ + kHeaderSize + reservations_size;
2662 return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
2663 GetHeaderValue(kNumCodeStubKeysOffset));
2667 SerializedCodeData::SerializedCodeData(ScriptData* data)
2668 : SerializedData(const_cast<byte*>(data->data()), data->length()) {}
2671 SerializedCodeData* SerializedCodeData::FromCachedData(ScriptData* cached_data,
2673 DisallowHeapAllocation no_gc;
2674 SerializedCodeData* scd = new SerializedCodeData(cached_data);
2675 SanityCheckResult r = scd->SanityCheck(source);
2676 if (r == CHECK_SUCCESS) return scd;
2677 cached_data->Reject();
2678 source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(r);
2682 } } // namespace v8::internal