Line data    Source code

       1             : // Copyright 2012 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_SOURCE_SINK_H_
       6             : #define V8_SNAPSHOT_SNAPSHOT_SOURCE_SINK_H_
       7             : 
       8             : #include "src/base/logging.h"
       9             : #include "src/utils.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : 
      15             : /**
      16             :  * Source to read snapshot and builtins files from.
      17             :  *
      18             :  * Note: Memory ownership remains with callee.
      19             :  */
      20             : class SnapshotByteSource final {
      21             :  public:
      22             :   SnapshotByteSource(const char* data, int length)
      23             :       : data_(reinterpret_cast<const byte*>(data)),
      24             :         length_(length),
      25       59478 :         position_(0) {}
      26             : 
      27             :   explicit SnapshotByteSource(Vector<const byte> payload)
      28      167930 :       : data_(payload.start()), length_(payload.length()), position_(0) {}
      29             : 
      30             :   ~SnapshotByteSource() {}
      31             : 
      32             :   bool HasMore() { return position_ < length_; }
      33             : 
      34             :   byte Get() {
      35             :     DCHECK(position_ < length_);
      36  5700112097 :     return data_[position_++];
      37             :   }
      38             : 
      39  3428232979 :   void Advance(int by) { position_ += by; }
      40             : 
      41             :   void CopyRaw(byte* to, int number_of_bytes);
      42             : 
      43  3425853859 :   inline int GetInt() {
      44             :     // This way of decoding variable-length encoded integers does not
      45             :     // suffer from branch mispredictions.
      46             :     DCHECK(position_ + 3 < length_);
      47  3425853859 :     uint32_t answer = data_[position_];
      48  3425853859 :     answer |= data_[position_ + 1] << 8;
      49  3425853859 :     answer |= data_[position_ + 2] << 16;
      50  3425853859 :     answer |= data_[position_ + 3] << 24;
      51  3425853859 :     int bytes = (answer & 3) + 1;
      52             :     Advance(bytes);
      53             :     uint32_t mask = 0xffffffffu;
      54  3425853859 :     mask >>= 32 - (bytes << 3);
      55  3425853859 :     answer &= mask;
      56  3425853859 :     answer >>= 2;
      57  3425853859 :     return answer;
      58             :   }
      59             : 
      60             :   // Returns length.
      61             :   int GetBlob(const byte** data);
      62             : 
      63             :   int position() { return position_; }
      64             : 
      65             :  private:
      66             :   const byte* data_;
      67             :   int length_;
      68             :   int position_;
      69             : 
      70             :   DISALLOW_COPY_AND_ASSIGN(SnapshotByteSource);
      71             : };
      72             : 
      73             : 
      74             : /**
      75             :  * Sink to write snapshot files to.
      76             :  *
      77             :  * Subclasses must implement actual storage or i/o.
      78             :  */
      79             : class SnapshotByteSink {
      80             :  public:
      81             :   SnapshotByteSink() {}
      82             :   explicit SnapshotByteSink(int initial_size) : data_(initial_size) {}
      83             : 
      84             :   ~SnapshotByteSink() {}
      85             : 
      86    26426834 :   void Put(byte b, const char* description) { data_.Add(b); }
      87             : 
      88             :   void PutSection(int b, const char* description) {
      89             :     DCHECK_LE(b, kMaxUInt8);
      90     1585238 :     Put(static_cast<byte>(b), description);
      91             :   }
      92             : 
      93             :   void PutInt(uintptr_t integer, const char* description);
      94             :   void PutRaw(const byte* data, int number_of_bytes, const char* description);
      95        3394 :   int Position() { return data_.length(); }
      96             : 
      97             :   const List<byte>* data() const { return &data_; }
      98             : 
      99             :  private:
     100             :   List<byte> data_;
     101             : };
     102             : 
     103             : }  // namespace internal
     104             : }  // namespace v8
     105             : 
     106             : #endif  // V8_SNAPSHOT_SNAPSHOT_SOURCE_SINK_H_