Line data Source code
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:
35 302 : 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.
39 452284 : bool LookupOrInsert(HeapObject* obj, int* index_out) {
40 452284 : Maybe<uint32_t> maybe_index = map_.Get(obj);
41 452284 : if (maybe_index.IsJust()) {
42 205401 : *index_out = maybe_index.FromJust();
43 205401 : return true;
44 : }
45 246883 : *index_out = next_index_;
46 246883 : map_.Set(obj, next_index_++);
47 246883 : 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 VisitRootPointers(Root root, 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 : List<AccessorInfo*> accessor_infos_;
77 : DISALLOW_COPY_AND_ASSIGN(StartupSerializer);
78 : };
79 :
80 : } // namespace internal
81 : } // namespace v8
82 :
83 : #endif // V8_SNAPSHOT_STARTUP_SERIALIZER_H_
|