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_
|