1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// Copyright 2017 The Chromium 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 COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
#define COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
#include <stddef.h>
#include <stdint.h>
#include <initializer_list>
#include <type_traits>
#include "base/check_op.h"
#include "components/zucchini/buffer_view.h"
namespace zucchini {
// BufferSource acts like an input stream with convenience methods to parse data
// from a contiguous sequence of raw data. The underlying ConstBufferView
// emulates a cursor to track current read position, and guards against buffer
// overrun. Where applicable, BufferSource should be passed by pointer to
// maintain cursor progress across reads.
class BufferSource : public ConstBufferView {
public:
// LEB128 info: http://dwarfstd.org/doc/dwarf-2.0.0.pdf , Section 7.6.
enum : size_t { kMaxLeb128Size = 5 };
static BufferSource FromRange(const_iterator first, const_iterator last) {
return BufferSource(ConstBufferView::FromRange(first, last));
}
using ConstBufferView::ConstBufferView;
BufferSource() = default;
explicit BufferSource(ConstBufferView buffer);
BufferSource(const BufferSource&) = default;
BufferSource& operator=(BufferSource&&) = default;
// Moves the cursor forward by |n| bytes, or to the end if data is exhausted.
// Returns a reference to *this, to allow chaining, e.g.:
// if (!buffer_source.Skip(1024).GetValue<uint32_t>(&value)) {
// ... // Handle error.
// }
// Notice that Skip() defers error handling to GetValue().
BufferSource& Skip(size_type n);
// Returns true if |value| matches data starting at the cursor when
// reinterpreted as the integral type |T|.
template <class T>
bool CheckNextValue(const T& value) const {
static_assert(std::is_integral<T>::value,
"Value type must be an integral type");
DCHECK_NE(begin(), nullptr);
if (Remaining() < sizeof(T))
return false;
return value == *reinterpret_cast<const T*>(begin());
}
// Returns true if the next bytes.size() bytes at the cursor match those in
// |bytes|.
bool CheckNextBytes(std::initializer_list<uint8_t> bytes) const;
// Same as CheckNextBytes(), but moves the cursor by bytes.size() if read is
// successfull.
bool ConsumeBytes(std::initializer_list<uint8_t> bytes);
// Tries to reinterpret data as type |T|, starting at the cursor and to write
// the result into |value|, while moving the cursor forward by sizeof(T).
// Returns true if sufficient data is available, and false otherwise.
template <class T>
bool GetValue(T* value) {
static_assert(std::is_standard_layout<T>::value,
"Value type must be a standard layout type");
DCHECK_NE(begin(), nullptr);
if (Remaining() < sizeof(T))
return false;
*value = *reinterpret_cast<const T*>(begin());
remove_prefix(sizeof(T));
return true;
}
// Tries to reinterpret data as type |T| at the cursor and to return a
// reinterpreted pointer of type |T| pointing into the underlying data, while
// moving the cursor forward by sizeof(T). Returns nullptr if insufficient
// data is available.
template <class T>
const T* GetPointer() {
static_assert(std::is_standard_layout<T>::value,
"Value type must be a standard layout type");
DCHECK_NE(begin(), nullptr);
if (Remaining() < sizeof(T))
return nullptr;
const T* ptr = reinterpret_cast<const T*>(begin());
remove_prefix(sizeof(T));
return ptr;
}
// Tries to reinterpret data as an array of type |T| with |count| elements,
// starting at the cursor, and to return a reinterpreted pointer of type |T|
// pointing into the underlying data, while advancing the cursor beyond the
// array. Returns nullptr if insufficient data is available.
template <class T>
const T* GetArray(size_t count) {
static_assert(std::is_standard_layout<T>::value,
"Value type must be a standard layout type");
if (Remaining() / sizeof(T) < count)
return nullptr;
const T* array = reinterpret_cast<const T*>(begin());
remove_prefix(count * sizeof(T));
return array;
}
// If sufficient data is available, assigns |buffer| to point to a region of
// |size| bytes starting at the cursor, while advancing the cursor beyond the
// region, and returns true. Otherwise returns false.
bool GetRegion(size_type size, ConstBufferView* buffer);
// Reads an Unsigned Little Endian Base 128 (uleb128) int at |first_|. If
// successful, writes the result to |value|, advances |first_|, and returns
// true. Otherwise returns false.
bool GetUleb128(uint32_t* value);
// Reads a Signed Little Endian Base 128 (sleb128) int at |first_|. If
// successful, writes the result to |value|, advances |first_|, and returns
// true. Otherwise returns false.
bool GetSleb128(int32_t* value);
// Reads uleb128 / sleb128 at |first_| but discards the result. If successful,
// advances |first_| and returns true. Otherwise returns false.
bool SkipLeb128();
// Returns the number of bytes remaining from cursor until end.
size_type Remaining() const { return size(); }
};
} // namespace zucchini
#endif // COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
|
