LLVM 17.0.0git
DataExtractor.cpp
Go to the documentation of this file.
1//===-- DataExtractor.cpp -------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
10#include "llvm/Support/Errc.h"
12#include "llvm/Support/LEB128.h"
14
15using namespace llvm;
16
17bool DataExtractor::prepareRead(uint64_t Offset, uint64_t Size,
18 Error *E) const {
20 return true;
21 if (E) {
22 if (Offset <= Data.size())
25 "unexpected end of data at offset 0x%zx while reading [0x%" PRIx64
26 ", 0x%" PRIx64 ")",
27 Data.size(), Offset, Offset + Size);
28 else
30 "offset 0x%" PRIx64
31 " is beyond the end of data at 0x%zx",
32 Offset, Data.size());
33 }
34 return false;
35}
36
37static bool isError(Error *E) { return E && *E; }
38
39template <typename T>
40T DataExtractor::getU(uint64_t *offset_ptr, Error *Err) const {
41 ErrorAsOutParameter ErrAsOut(Err);
42 T val = 0;
43 if (isError(Err))
44 return val;
45
46 uint64_t offset = *offset_ptr;
47 if (!prepareRead(offset, sizeof(T), Err))
48 return val;
49 std::memcpy(&val, &Data.data()[offset], sizeof(val));
50 if (sys::IsLittleEndianHost != IsLittleEndian)
52
53 // Advance the offset
54 *offset_ptr += sizeof(val);
55 return val;
56}
57
58template <typename T>
59T *DataExtractor::getUs(uint64_t *offset_ptr, T *dst, uint32_t count,
60 Error *Err) const {
61 ErrorAsOutParameter ErrAsOut(Err);
62 if (isError(Err))
63 return nullptr;
64
65 uint64_t offset = *offset_ptr;
66
67 if (!prepareRead(offset, sizeof(*dst) * count, Err))
68 return nullptr;
69 for (T *value_ptr = dst, *end = dst + count; value_ptr != end;
70 ++value_ptr, offset += sizeof(*dst))
71 *value_ptr = getU<T>(offset_ptr, Err);
72 // Advance the offset
73 *offset_ptr = offset;
74 // Return a non-NULL pointer to the converted data as an indicator of
75 // success
76 return dst;
77}
78
79uint8_t DataExtractor::getU8(uint64_t *offset_ptr, llvm::Error *Err) const {
80 return getU<uint8_t>(offset_ptr, Err);
81}
82
83uint8_t *DataExtractor::getU8(uint64_t *offset_ptr, uint8_t *dst,
84 uint32_t count) const {
85 return getUs<uint8_t>(offset_ptr, dst, count, nullptr);
86}
87
88uint8_t *DataExtractor::getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const {
89 return getUs<uint8_t>(&C.Offset, Dst, Count, &C.Err);
90}
91
93 return getU<uint16_t>(offset_ptr, Err);
94}
95
97 uint32_t count) const {
98 return getUs<uint16_t>(offset_ptr, dst, count, nullptr);
99}
100
102 uint24_t ExtractedVal = getU<uint24_t>(OffsetPtr, Err);
103 // The 3 bytes are in the correct byte order for the host.
104 return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
105}
106
108 return getU<uint32_t>(offset_ptr, Err);
109}
110
112 uint32_t count) const {
113 return getUs<uint32_t>(offset_ptr, dst, count, nullptr);
114}
115
117 return getU<uint64_t>(offset_ptr, Err);
118}
119
121 uint32_t count) const {
122 return getUs<uint64_t>(offset_ptr, dst, count, nullptr);
123}
124
126 llvm::Error *Err) const {
127 switch (byte_size) {
128 case 1:
129 return getU8(offset_ptr, Err);
130 case 2:
131 return getU16(offset_ptr, Err);
132 case 4:
133 return getU32(offset_ptr, Err);
134 case 8:
135 return getU64(offset_ptr, Err);
136 }
137 llvm_unreachable("getUnsigned unhandled case!");
138}
139
140int64_t
141DataExtractor::getSigned(uint64_t *offset_ptr, uint32_t byte_size) const {
142 switch (byte_size) {
143 case 1:
144 return (int8_t)getU8(offset_ptr);
145 case 2:
146 return (int16_t)getU16(offset_ptr);
147 case 4:
148 return (int32_t)getU32(offset_ptr);
149 case 8:
150 return (int64_t)getU64(offset_ptr);
151 }
152 llvm_unreachable("getSigned unhandled case!");
153}
154
156 ErrorAsOutParameter ErrAsOut(Err);
157 if (isError(Err))
158 return StringRef();
159
160 uint64_t Start = *OffsetPtr;
161 StringRef::size_type Pos = Data.find('\0', Start);
162 if (Pos != StringRef::npos) {
163 *OffsetPtr = Pos + 1;
164 return StringRef(Data.data() + Start, Pos - Start);
165 }
166 if (Err)
168 "no null terminated string at offset 0x%" PRIx64,
169 Start);
170 return StringRef();
171}
172
175 StringRef TrimChars) const {
176 StringRef Bytes(getBytes(OffsetPtr, Length));
177 return Bytes.trim(TrimChars);
178}
179
181 Error *Err) const {
182 ErrorAsOutParameter ErrAsOut(Err);
183 if (isError(Err))
184 return StringRef();
185
186 if (!prepareRead(*OffsetPtr, Length, Err))
187 return StringRef();
188
189 StringRef Result = Data.substr(*OffsetPtr, Length);
190 *OffsetPtr += Length;
191 return Result;
192}
193
194template <typename T>
195static T getLEB128(StringRef Data, uint64_t *OffsetPtr, Error *Err,
196 T (&Decoder)(const uint8_t *p, unsigned *n,
197 const uint8_t *end, const char **error)) {
198 ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(Data);
199 assert(*OffsetPtr <= Bytes.size());
200 ErrorAsOutParameter ErrAsOut(Err);
201 if (isError(Err))
202 return T();
203
204 const char *error;
205 unsigned bytes_read;
206 T result =
207 Decoder(Bytes.data() + *OffsetPtr, &bytes_read, Bytes.end(), &error);
208 if (error) {
209 if (Err)
211 "unable to decode LEB128 at offset 0x%8.8" PRIx64
212 ": %s",
213 *OffsetPtr, error);
214 return T();
215 }
216 *OffsetPtr += bytes_read;
217 return result;
218}
219
221 return getLEB128(Data, offset_ptr, Err, decodeULEB128);
222}
223
224int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr, Error *Err) const {
225 return getLEB128(Data, offset_ptr, Err, decodeSLEB128);
226}
227
229 ErrorAsOutParameter ErrAsOut(&C.Err);
230 if (isError(&C.Err))
231 return;
232
233 if (prepareRead(C.Offset, Length, &C.Err))
234 C.Offset += Length;
235}
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static T getLEB128(StringRef Data, uint64_t *OffsetPtr, Error *Err, T(&Decoder)(const uint8_t *p, unsigned *n, const uint8_t *end, const char **error))
static bool isError(Error *E)
uint64_t Size
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
#define error(X)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator end() const
Definition: ArrayRef.h:152
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
const T * data() const
Definition: ArrayRef.h:160
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
StringRef getFixedLengthString(uint64_t *OffsetPtr, uint64_t Length, StringRef TrimChars={"\0", 1}) const
Extract a fixed length string from *OffsetPtr and consume Length bytes.
uint64_t getUnsigned(uint64_t *offset_ptr, uint32_t byte_size, Error *Err=nullptr) const
Extract an unsigned integer of size byte_size from *offset_ptr.
uint32_t getU32(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint32_t value from *offset_ptr.
StringRef getCStrRef(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
uint8_t getU8(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint8_t value from *offset_ptr.
int64_t getSigned(uint64_t *offset_ptr, uint32_t size) const
Extract an signed integer of size byte_size from *offset_ptr.
uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err=nullptr) const
Extract a unsigned LEB128 value from *offset_ptr.
int64_t getSLEB128(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a signed LEB128 value from *offset_ptr.
uint16_t getU16(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint16_t value from *offset_ptr.
void skip(Cursor &C, uint64_t Length) const
Advance the Cursor position by the given number of bytes.
uint64_t getU64(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint64_t value from *offset_ptr.
bool isValidOffsetForDataOfSize(uint64_t offset, uint64_t length) const
Test the availability of length bytes of data from offset.
StringRef getBytes(uint64_t *OffsetPtr, uint64_t Length, Error *Err=nullptr) const
Extract a fixed number of bytes from the specified offset.
uint32_t getU24(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a 24-bit unsigned value from *offset_ptr and return it in a uint32_t.
Helper for Errors used as out-parameters.
Definition: Error.h:1104
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:558
size_t size_type
Definition: StringRef.h:56
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:295
StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
Definition: StringRef.h:802
static constexpr size_t npos
Definition: StringRef.h:52
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:235
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:70
void swapByteOrder(T &Value)
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:406
@ Length
Definition: DWP.cpp:406
uint64_t decodeULEB128(const uint8_t *p, unsigned *n=nullptr, const uint8_t *end=nullptr, const char **error=nullptr)
Utility function to decode a ULEB128 value.
Definition: LEB128.h:128
int64_t decodeSLEB128(const uint8_t *p, unsigned *n=nullptr, const uint8_t *end=nullptr, const char **error=nullptr)
Utility function to decode a SLEB128 value.
Definition: LEB128.h:161
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1246
@ illegal_byte_sequence
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:1974
An auxiliary type to facilitate extraction of 3-byte entities.
Definition: DataExtractor.h:19
uint32_t getAsUint32(bool IsLittleEndian) const
Definition: DataExtractor.h:27