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
12namespace v8 {
13namespace internal {
14
15class 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    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    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