| // 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. |
| |
| #ifndef V8_SNAPSHOT_SERIALIZER_COMMON_H_ |
| #define V8_SNAPSHOT_SERIALIZER_COMMON_H_ |
| |
| #include "src/address-map.h" |
| #include "src/external-reference-table.h" |
| #include "src/globals.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| class Isolate; |
| |
| class ExternalReferenceEncoder { |
| public: |
| explicit ExternalReferenceEncoder(Isolate* isolate); |
| |
| uint32_t Encode(Address key) const; |
| |
| const char* NameOfAddress(Isolate* isolate, Address address) const; |
| |
| private: |
| static uint32_t Hash(Address key) { |
| return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(key) >> |
| kPointerSizeLog2); |
| } |
| |
| base::HashMap* map_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ExternalReferenceEncoder); |
| }; |
| |
| class HotObjectsList { |
| public: |
| HotObjectsList() : index_(0) { |
| for (int i = 0; i < kSize; i++) circular_queue_[i] = NULL; |
| } |
| |
| void Add(HeapObject* object) { |
| DCHECK(!AllowHeapAllocation::IsAllowed()); |
| circular_queue_[index_] = object; |
| index_ = (index_ + 1) & kSizeMask; |
| } |
| |
| HeapObject* Get(int index) { |
| DCHECK(!AllowHeapAllocation::IsAllowed()); |
| DCHECK_NOT_NULL(circular_queue_[index]); |
| return circular_queue_[index]; |
| } |
| |
| static const int kNotFound = -1; |
| |
| int Find(HeapObject* object) { |
| DCHECK(!AllowHeapAllocation::IsAllowed()); |
| for (int i = 0; i < kSize; i++) { |
| if (circular_queue_[i] == object) return i; |
| } |
| return kNotFound; |
| } |
| |
| static const int kSize = 8; |
| |
| private: |
| STATIC_ASSERT(IS_POWER_OF_TWO(kSize)); |
| static const int kSizeMask = kSize - 1; |
| HeapObject* circular_queue_[kSize]; |
| int index_; |
| |
| DISALLOW_COPY_AND_ASSIGN(HotObjectsList); |
| }; |
| |
| // The Serializer/Deserializer class is a common superclass for Serializer and |
| // Deserializer which is used to store common constants and methods used by |
| // both. |
| class SerializerDeserializer : public ObjectVisitor { |
| public: |
| static void Iterate(Isolate* isolate, ObjectVisitor* visitor); |
| |
| // No reservation for large object space necessary. |
| // We also handle map space differenly. |
| STATIC_ASSERT(MAP_SPACE == CODE_SPACE + 1); |
| static const int kNumberOfPreallocatedSpaces = CODE_SPACE + 1; |
| static const int kNumberOfSpaces = LAST_SPACE + 1; |
| |
| protected: |
| static bool CanBeDeferred(HeapObject* o); |
| |
| // ---------- byte code range 0x00..0x7f ---------- |
| // Byte codes in this range represent Where, HowToCode and WhereToPoint. |
| // Where the pointed-to object can be found: |
| // The static assert below will trigger when the number of preallocated spaces |
| // changed. If that happens, update the bytecode ranges in the comments below. |
| STATIC_ASSERT(5 == kNumberOfSpaces); |
| enum Where { |
| // 0x00..0x04 Allocate new object, in specified space. |
| kNewObject = 0x00, |
| // 0x08..0x0c Reference to previous object from space. |
| kBackref = 0x08, |
| // 0x10..0x14 Reference to previous object from space after skip. |
| kBackrefWithSkip = 0x10, |
| |
| // 0x05 Root array item. |
| kRootArray = 0x05, |
| // 0x06 Object in the partial snapshot cache. |
| kPartialSnapshotCache = 0x06, |
| // 0x07 External reference referenced by id. |
| kExternalReference = 0x07, |
| |
| // 0x0d Object provided in the attached list. |
| kAttachedReference = 0x0d, |
| // 0x0e Builtin code referenced by index. |
| kBuiltin = 0x0e, |
| |
| // 0x0f Misc, see below (incl. 0x2f, 0x4f, 0x6f). |
| // 0x15..0x1f Misc, see below (incl. 0x35..0x3f, 0x55..0x5f, 0x75..0x7f). |
| }; |
| |
| static const int kWhereMask = 0x1f; |
| static const int kSpaceMask = 7; |
| STATIC_ASSERT(kNumberOfSpaces <= kSpaceMask + 1); |
| |
| // How to code the pointer to the object. |
| enum HowToCode { |
| // Straight pointer. |
| kPlain = 0, |
| // A pointer inlined in code. What this means depends on the architecture. |
| kFromCode = 0x20 |
| }; |
| |
| static const int kHowToCodeMask = 0x20; |
| |
| // Where to point within the object. |
| enum WhereToPoint { |
| // Points to start of object |
| kStartOfObject = 0, |
| // Points to instruction in code object or payload of cell. |
| kInnerPointer = 0x40 |
| }; |
| |
| static const int kWhereToPointMask = 0x40; |
| |
| // ---------- Misc ---------- |
| // Skip. |
| static const int kSkip = 0x0f; |
| // Do nothing, used for padding. |
| static const int kNop = 0x2f; |
| // Move to next reserved chunk. |
| static const int kNextChunk = 0x4f; |
| // Deferring object content. |
| static const int kDeferred = 0x6f; |
| // Alignment prefixes 0x15..0x17 |
| static const int kAlignmentPrefix = 0x15; |
| // A tag emitted at strategic points in the snapshot to delineate sections. |
| // If the deserializer does not find these at the expected moments then it |
| // is an indication that the snapshot and the VM do not fit together. |
| // Examine the build process for architecture, version or configuration |
| // mismatches. |
| static const int kSynchronize = 0x18; |
| // Repeats of variable length. |
| static const int kVariableRepeat = 0x19; |
| // Raw data of variable length. |
| static const int kVariableRawData = 0x1a; |
| // Internal reference encoded as offsets of pc and target from code entry. |
| static const int kInternalReference = 0x1b; |
| static const int kInternalReferenceEncoded = 0x1c; |
| // Used for the source code of the natives, which is in the executable, but |
| // is referred to from external strings in the snapshot. |
| static const int kNativesStringResource = 0x1d; |
| // Used for the source code for compiled stubs, which is in the executable, |
| // but is referred to from external strings in the snapshot. |
| static const int kExtraNativesStringResource = 0x1e; |
| |
| // 8 hot (recently seen or back-referenced) objects with optional skip. |
| static const int kNumberOfHotObjects = 8; |
| STATIC_ASSERT(kNumberOfHotObjects == HotObjectsList::kSize); |
| // 0x38..0x3f |
| static const int kHotObject = 0x38; |
| // 0x58..0x5f |
| static const int kHotObjectWithSkip = 0x58; |
| static const int kHotObjectMask = 0x07; |
| |
| // 0x1f, 0x35..0x37, 0x55..0x57, 0x75..0x7f unused. |
| |
| // ---------- byte code range 0x80..0xff ---------- |
| // First 32 root array items. |
| static const int kNumberOfRootArrayConstants = 0x20; |
| // 0x80..0x9f |
| static const int kRootArrayConstants = 0x80; |
| // 0xa0..0xbf |
| static const int kRootArrayConstantsWithSkip = 0xa0; |
| static const int kRootArrayConstantsMask = 0x1f; |
| |
| // 32 common raw data lengths. |
| static const int kNumberOfFixedRawData = 0x20; |
| // 0xc0..0xdf |
| static const int kFixedRawData = 0xc0; |
| static const int kOnePointerRawData = kFixedRawData; |
| static const int kFixedRawDataStart = kFixedRawData - 1; |
| |
| // 16 repeats lengths. |
| static const int kNumberOfFixedRepeat = 0x10; |
| // 0xe0..0xef |
| static const int kFixedRepeat = 0xe0; |
| static const int kFixedRepeatStart = kFixedRepeat - 1; |
| |
| // 0xf0..0xff unused. |
| |
| // ---------- special values ---------- |
| static const int kAnyOldSpace = -1; |
| |
| // Sentinel after a new object to indicate that double alignment is needed. |
| static const int kDoubleAlignmentSentinel = 0; |
| |
| // ---------- member variable ---------- |
| HotObjectsList hot_objects_; |
| }; |
| |
| class SerializedData { |
| public: |
| class Reservation { |
| public: |
| explicit Reservation(uint32_t size) |
| : reservation_(ChunkSizeBits::encode(size)) {} |
| |
| uint32_t chunk_size() const { return ChunkSizeBits::decode(reservation_); } |
| bool is_last() const { return IsLastChunkBits::decode(reservation_); } |
| |
| void mark_as_last() { reservation_ |= IsLastChunkBits::encode(true); } |
| |
| private: |
| uint32_t reservation_; |
| }; |
| |
| SerializedData(byte* data, int size) |
| : data_(data), size_(size), owns_data_(false) {} |
| SerializedData() : data_(NULL), size_(0), owns_data_(false) {} |
| |
| ~SerializedData() { |
| if (owns_data_) DeleteArray<byte>(data_); |
| } |
| |
| uint32_t GetMagicNumber() const { return GetHeaderValue(kMagicNumberOffset); } |
| |
| class ChunkSizeBits : public BitField<uint32_t, 0, 31> {}; |
| class IsLastChunkBits : public BitField<bool, 31, 1> {}; |
| |
| static uint32_t ComputeMagicNumber(ExternalReferenceTable* table) { |
| uint32_t external_refs = table->size(); |
| return 0xC0DE0000 ^ external_refs; |
| } |
| |
| protected: |
| void SetHeaderValue(int offset, uint32_t value) { |
| uint32_t* address = reinterpret_cast<uint32_t*>(data_ + offset); |
| memcpy(reinterpret_cast<uint32_t*>(address), &value, sizeof(value)); |
| } |
| |
| uint32_t GetHeaderValue(int offset) const { |
| uint32_t value; |
| memcpy(&value, reinterpret_cast<int*>(data_ + offset), sizeof(value)); |
| return value; |
| } |
| |
| void AllocateData(int size); |
| |
| static uint32_t ComputeMagicNumber(Isolate* isolate) { |
| return ComputeMagicNumber(ExternalReferenceTable::instance(isolate)); |
| } |
| |
| void SetMagicNumber(Isolate* isolate) { |
| SetHeaderValue(kMagicNumberOffset, ComputeMagicNumber(isolate)); |
| } |
| |
| static const int kMagicNumberOffset = 0; |
| |
| byte* data_; |
| int size_; |
| bool owns_data_; |
| }; |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_SNAPSHOT_SERIALIZER_COMMON_H_ |