Home | History | Annotate | Download | only in src 
      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_SOURCE_SINK_H_
      6 #define V8_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 byte* array, int length);
     23   ~SnapshotByteSource();
     24 
     25   bool HasMore() { return position_ < length_; }
     26 
     27   int Get() {
     28     DCHECK(position_ < length_);
     29     return data_[position_++];
     30   }
     31 
     32   int32_t GetUnalignedInt();
     33 
     34   void Advance(int by) { position_ += by; }
     35 
     36   void CopyRaw(byte* to, int number_of_bytes);
     37 
     38   inline int GetInt() {
     39     // This way of variable-length encoding integers does not suffer from branch
     40     // mispredictions.
     41     uint32_t answer = GetUnalignedInt();
     42     int bytes = answer & 3;
     43     Advance(bytes);
     44     uint32_t mask = 0xffffffffu;
     45     mask >>= 32 - (bytes << 3);
     46     answer &= mask;
     47     answer >>= 2;
     48     return answer;
     49   }
     50 
     51   bool GetBlob(const byte** data, int* number_of_bytes);
     52 
     53   bool AtEOF();
     54 
     55   int position() { return position_; }
     56 
     57  private:
     58   const byte* data_;
     59   int length_;
     60   int position_;
     61 
     62   DISALLOW_COPY_AND_ASSIGN(SnapshotByteSource);
     63 };
     64 
     65 
     66 /**
     67  * Sink to write snapshot files to.
     68  *
     69  * Subclasses must implement actual storage or i/o.
     70  */
     71 class SnapshotByteSink {
     72  public:
     73   virtual ~SnapshotByteSink() { }
     74   virtual void Put(byte b, const char* description) = 0;
     75   virtual void PutSection(int b, const char* description) {
     76     DCHECK_LE(b, kMaxUInt8);
     77     Put(static_cast<byte>(b), description);
     78   }
     79   void PutInt(uintptr_t integer, const char* description);
     80   void PutRaw(byte* data, int number_of_bytes, const char* description);
     81   void PutBlob(byte* data, int number_of_bytes, const char* description);
     82   virtual int Position() = 0;
     83 };
     84 
     85 
     86 class DummySnapshotSink : public SnapshotByteSink {
     87  public:
     88   DummySnapshotSink() : length_(0) {}
     89   virtual ~DummySnapshotSink() {}
     90   virtual void Put(byte b, const char* description) { length_++; }
     91   virtual int Position() { return length_; }
     92 
     93  private:
     94   int length_;
     95 };
     96 
     97 
     98 // Wrap a SnapshotByteSink into a DebugSnapshotSink to get debugging output.
     99 class DebugSnapshotSink : public SnapshotByteSink {
    100  public:
    101   explicit DebugSnapshotSink(SnapshotByteSink* chained) : sink_(chained) {}
    102   virtual void Put(byte b, const char* description) OVERRIDE;
    103   virtual int Position() OVERRIDE { return sink_->Position(); }
    104 
    105  private:
    106   SnapshotByteSink* sink_;
    107 };
    108 
    109 
    110 class ListSnapshotSink : public i::SnapshotByteSink {
    111  public:
    112   explicit ListSnapshotSink(i::List<byte>* data) : data_(data) {}
    113   virtual void Put(byte b, const char* description) OVERRIDE {
    114     data_->Add(b);
    115   }
    116   virtual int Position() OVERRIDE { return data_->length(); }
    117 
    118  private:
    119   i::List<byte>* data_;
    120 };
    121 
    122 }  // namespace v8::internal
    123 }  // namespace v8
    124 
    125 #endif  // V8_SNAPSHOT_SOURCE_SINK_H_
    126