Home | History | Annotate | Download | only in snapshot 
      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     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   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_
     84