blob: 190cc595291d3be8ef63ccf8172b300dc8e18a94 [file] [log] [blame]
// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <bitset>
#include "include/v8.h"
#include "src/snapshot/serializer.h"
namespace v8 {
namespace internal {
class StartupSerializer : public Serializer<> {
explicit StartupSerializer(Isolate* isolate);
~StartupSerializer() override;
// Serialize the current state of the heap. The order is:
// 1) Immortal immovable roots
// 2) Remaining strong references.
// 3) Partial snapshot cache.
// 4) Weak references (e.g. the string table).
void SerializeStrongReferences();
void SerializeWeakReferencesAndDeferred();
int PartialSnapshotCacheIndex(HeapObject* o);
bool can_be_rehashed() const { return can_be_rehashed_; }
bool root_has_been_serialized(int root_index) const {
return root_has_been_serialized_.test(root_index);
class PartialCacheIndexMap {
PartialCacheIndexMap() : map_(), next_index_(0) {}
// Lookup object in the map. Return its index if found, or create
// a new entry with new_index as value, and return kInvalidIndex.
bool LookupOrInsert(HeapObject* obj, int* index_out) {
Maybe<uint32_t> maybe_index = map_.Get(obj);
if (maybe_index.IsJust()) {
*index_out = maybe_index.FromJust();
return true;
*index_out = next_index_;
map_.Set(obj, next_index_++);
return false;
DisallowHeapAllocation no_allocation_;
HeapObjectToIndexHashMap map_;
int next_index_;
// The StartupSerializer has to serialize the root array, which is slightly
// different.
void VisitRootPointers(Root root, const char* description, Object** start,
Object** end) override;
void SerializeObject(HeapObject* o, HowToCode how_to_code,
WhereToPoint where_to_point, int skip) override;
void Synchronize(VisitorSynchronization::SyncTag tag) override;
bool MustBeDeferred(HeapObject* object) override;
void CheckRehashability(HeapObject* obj);
std::bitset<Heap::kStrongRootListLength> root_has_been_serialized_;
PartialCacheIndexMap partial_cache_index_map_;
std::vector<AccessorInfo*> accessor_infos_;
std::vector<CallHandlerInfo*> call_handler_infos_;
// Indicates whether we only serialized hash tables that we can rehash.
// TODO(yangguo): generalize rehashing, and remove this flag.
bool can_be_rehashed_;
class SerializedHandleChecker : public RootVisitor {
SerializedHandleChecker(Isolate* isolate, std::vector<Context*>* contexts);
virtual void VisitRootPointers(Root root, const char* description,
Object** start, Object** end);
bool CheckGlobalAndEternalHandles();
void AddToSet(FixedArray* serialized);
Isolate* isolate_;
std::unordered_set<Object*> serialized_;
bool ok_ = true;
} // namespace internal
} // namespace v8