Line data    Source code

       1             : // Copyright 2006-2008 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_SNAPSHOT_H_
       6             : #define V8_SNAPSHOT_SNAPSHOT_H_
       7             : 
       8             : #include "src/snapshot/partial-serializer.h"
       9             : #include "src/snapshot/startup-serializer.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : // Forward declarations.
      15             : class Isolate;
      16             : class PartialSerializer;
      17             : class StartupSerializer;
      18             : 
      19             : // Wrapper around reservation sizes and the serialization payload.
      20             : class SnapshotData : public SerializedData {
      21             :  public:
      22             :   // Used when producing.
      23             :   explicit SnapshotData(const Serializer* serializer);
      24             : 
      25             :   // Used when consuming.
      26      167545 :   explicit SnapshotData(const Vector<const byte> snapshot)
      27      167545 :       : SerializedData(const_cast<byte*>(snapshot.begin()), snapshot.length()) {
      28      167545 :     CHECK(IsSane());
      29      167545 :   }
      30             : 
      31             :   Vector<const Reservation> Reservations() const;
      32             :   Vector<const byte> Payload() const;
      33             : 
      34             :   Vector<const byte> RawData() const {
      35             :     return Vector<const byte>(data_, size_);
      36             :   }
      37             : 
      38             :  private:
      39             :   bool IsSane();
      40             : 
      41             :   // The data header consists of uint32_t-sized entries:
      42             :   // [0] magic number and (internal) external reference count
      43             :   // [1] API-provided external reference count
      44             :   // [2] version hash
      45             :   // [3] number of reservation size entries
      46             :   // [4] payload length
      47             :   // ... reservations
      48             :   // ... serialized payload
      49             :   static const int kNumReservationsOffset = kVersionHashOffset + kInt32Size;
      50             :   static const int kPayloadLengthOffset = kNumReservationsOffset + kInt32Size;
      51             :   static const int kHeaderSize = kPayloadLengthOffset + kInt32Size;
      52             : };
      53             : 
      54             : class Snapshot : public AllStatic {
      55             :  public:
      56             :   // Initialize the Isolate from the internal snapshot. Returns false if no
      57             :   // snapshot could be found.
      58             :   static bool Initialize(Isolate* isolate);
      59             :   // Create a new context using the internal partial snapshot.
      60             :   static MaybeHandle<Context> NewContextFromSnapshot(
      61             :       Isolate* isolate, Handle<JSGlobalProxy> global_proxy,
      62             :       size_t context_index,
      63             :       v8::DeserializeEmbedderFieldsCallback embedder_fields_deserializer);
      64             : 
      65             :   static bool HasContextSnapshot(Isolate* isolate, size_t index);
      66             : 
      67             :   static bool EmbedsScript(Isolate* isolate);
      68             : 
      69             :   // To be implemented by the snapshot source.
      70             :   static const v8::StartupData* DefaultSnapshotBlob();
      71             : 
      72             :   static v8::StartupData CreateSnapshotBlob(
      73             :       const SnapshotData* startup_snapshot,
      74             :       const List<SnapshotData*>* context_snapshots);
      75             : 
      76             : #ifdef DEBUG
      77             :   static bool SnapshotIsValid(v8::StartupData* snapshot_blob);
      78             : #endif  // DEBUG
      79             : 
      80             :  private:
      81             :   static int ExtractNumContexts(const v8::StartupData* data);
      82             :   static Vector<const byte> ExtractStartupData(const v8::StartupData* data);
      83             :   static Vector<const byte> ExtractContextData(const v8::StartupData* data,
      84             :                                                int index);
      85             : 
      86             :   // Snapshot blob layout:
      87             :   // [0] number of contexts N
      88             :   // [1] offset to context 0
      89             :   // [2] offset to context 1
      90             :   // ...
      91             :   // ... offset to context N - 1
      92             :   // ... startup snapshot data
      93             :   // ... context 0 snapshot data
      94             :   // ... context 1 snapshot data
      95             : 
      96             :   static const int kNumberOfContextsOffset = 0;
      97             :   static const int kFirstContextOffsetOffset =
      98             :       kNumberOfContextsOffset + kInt32Size;
      99             : 
     100             :   static int StartupSnapshotOffset(int num_contexts) {
     101       60794 :     return kFirstContextOffsetOffset + num_contexts * kInt32Size;
     102             :   }
     103             : 
     104             :   static int ContextSnapshotOffsetOffset(int index) {
     105      106987 :     return kFirstContextOffsetOffset + index * kInt32Size;
     106             :   }
     107             : 
     108             :   DISALLOW_IMPLICIT_CONSTRUCTORS(Snapshot);
     109             : };
     110             : 
     111             : #ifdef V8_USE_EXTERNAL_STARTUP_DATA
     112             : void SetSnapshotFromFile(StartupData* snapshot_blob);
     113             : #endif
     114             : 
     115             : }  // namespace internal
     116             : }  // namespace v8
     117             : 
     118             : #endif  // V8_SNAPSHOT_SNAPSHOT_H_