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_