1 // Copyright 2016 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. 4 5 #ifndef V8_SNAPSHOT_STARTUP_SERIALIZER_H_ 6 #define V8_SNAPSHOT_STARTUP_SERIALIZER_H_ 7 8 #include <bitset> 9 #include "include/v8.h" 10 #include "src/snapshot/serializer.h" 11 12 namespace v8 { 13 namespace internal { 14 15 class StartupSerializer : public Serializer { 16 public: 17 StartupSerializer( 18 Isolate* isolate, 19 v8::SnapshotCreator::FunctionCodeHandling function_code_handling); 20 ~StartupSerializer() override; 21 22 // Serialize the current state of the heap. The order is: 23 // 1) Immortal immovable roots 24 // 2) Remaining strong references. 25 // 3) Partial snapshot cache. 26 // 4) Weak references (e.g. the string table). 27 void SerializeStrongReferences(); 28 void SerializeWeakReferencesAndDeferred(); 29 30 int PartialSnapshotCacheIndex(HeapObject* o); 31 32 private: 33 class PartialCacheIndexMap : public AddressMapBase { 34 public: 35 PartialCacheIndexMap() 36 : map_(base::HashMap::PointersMatch), next_index_(0) {} 37 38 // Lookup object in the map. Return its index if found, or create 39 // a new entry with new_index as value, and return kInvalidIndex. 40 bool LookupOrInsert(HeapObject* obj, int* index_out) { 41 base::HashMap::Entry* entry = LookupEntry(&map_, obj, false); 42 if (entry != NULL) { 43 *index_out = GetValue(entry); 44 return true; 45 } 46 *index_out = next_index_; 47 SetValue(LookupEntry(&map_, obj, true), next_index_++); 48 return false; 49 } 50 51 private: 52 base::HashMap map_; 53 int next_index_; 54 55 DISALLOW_COPY_AND_ASSIGN(PartialCacheIndexMap); 56 }; 57 58 // The StartupSerializer has to serialize the root array, which is slightly 59 // different. 60 void VisitPointers(Object** start, Object** end) override; 61 void SerializeObject(HeapObject* o, HowToCode how_to_code, 62 WhereToPoint where_to_point, int skip) override; 63 void Synchronize(VisitorSynchronization::SyncTag tag) override; 64 65 // Some roots should not be serialized, because their actual value depends on 66 // absolute addresses and they are reset after deserialization, anyway. 67 // In the first pass over the root list, we only serialize immortal immovable 68 // roots. In the second pass, we serialize the rest. 69 bool RootShouldBeSkipped(int root_index); 70 71 bool clear_function_code_; 72 bool serializing_builtins_; 73 bool serializing_immortal_immovables_roots_; 74 std::bitset<Heap::kStrongRootListLength> root_has_been_serialized_; 75 PartialCacheIndexMap partial_cache_index_map_; 76 DISALLOW_COPY_AND_ASSIGN(StartupSerializer); 77 }; 78 79 } // namespace internal 80 } // namespace v8 81 82 #endif // V8_SNAPSHOT_STARTUP_SERIALIZER_H_ 83