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 { 34 public: PartialCacheIndexMap()35 PartialCacheIndexMap() : map_(), next_index_(0) {} 36 37 // Lookup object in the map. Return its index if found, or create 38 // a new entry with new_index as value, and return kInvalidIndex. LookupOrInsert(HeapObject * obj,int * index_out)39 bool LookupOrInsert(HeapObject* obj, int* index_out) { 40 Maybe<uint32_t> maybe_index = map_.Get(obj); 41 if (maybe_index.IsJust()) { 42 *index_out = maybe_index.FromJust(); 43 return true; 44 } 45 *index_out = next_index_; 46 map_.Set(obj, next_index_++); 47 return false; 48 } 49 50 private: 51 DisallowHeapAllocation no_allocation_; 52 HeapObjectToIndexHashMap 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