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 : public AddressMapBase {
     34    public:
     35     PartialCacheIndexMap()
     36         : map_(base::HashMap::PointersMatch), next_index_(0) {}
     37 
     38     // Lookup object in the map. Return its index if found, or create
     39     // a new entry with new_index as value, and return kInvalidIndex.
     40     bool LookupOrInsert(HeapObject* obj, int* index_out) {
     41       base::HashMap::Entry* entry = LookupEntry(&map_, obj, false);
     42       if (entry != NULL) {
     43         *index_out = GetValue(entry);
     44         return true;
     45       }
     46       *index_out = next_index_;
     47       SetValue(LookupEntry(&map_, obj, true), next_index_++);
     48       return false;
     49     }
     50 
     51    private:
     52     base::HashMap 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