LLVM 19.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
11#include "llvm/Support/Errc.h"
13#include "llvm/Support/LEB128.h"
15
16using namespace llvm;
17
18bool DataExtractor::prepareRead(uint64_t Offset, uint64_t Size,
19 Error *E) const {
21 return true;
22 if (E) {
23 if (Offset <= Data.size())
26 "unexpected end of data at offset 0x%zx while reading [0x%" PRIx64
27 ", 0x%" PRIx64 ")",
28 Data.size(), Offset, Offset + Size);
29 else
31 "offset 0x%" PRIx64
32 " is beyond the end of data at 0x%zx",
33 Offset, Data.size());
34 }
35 return false;
36}
37
38static bool isError(Error *E) { return E && *E; }
39
40template <typename T>
41T DataExtractor::getU(uint64_t *offset_ptr, Error *Err) const {
42 ErrorAsOutParameter ErrAsOut(Err);
43 T val = 0;
44 if (isError(Err))
45 return val;
46
47 uint64_t offset = *offset_ptr;
48 if (!prepareRead(offset, sizeof(T), Err))
49 return val;
50 std::memcpy(&val, &Data.data()[offset], sizeof(val));
51 if (sys::IsLittleEndianHost != IsLittleEndian)
53
54 // Advance the offset
55 *offset_ptr += sizeof(val);
56 return val;
57}
58
59template <typename T>
60T *DataExtractor::getUs(uint64_t *offset_ptr, T *dst, uint32_t count,
61 Error *Err) const {
62 ErrorAsOutParameter ErrAsOut(Err);
63 if (isError(Err))
64 return nullptr;
65
66 uint64_t offset = *offset_ptr;
67
68 if (!prepareRead(offset, sizeof(*dst) * count, Err))
69 return nullptr;
70 for (T *value_ptr = dst, *end = dst + count; value_ptr != end;
71 ++value_ptr, offset += sizeof(*dst))
72 *value_ptr = getU<T>(offset_ptr, Err);
73 // Advance the offset
74 *offset_ptr = offset;
75 // Return a non-NULL pointer to the converted data as an indicator of
76 // success
77 return dst;
78}
79
80uint8_t DataExtractor::getU8(uint64_t *offset_ptr, llvm::Error *Err) const {
81 return getU<uint8_t>(offset_ptr, Err);
82}
83
84uint8_t *DataExtractor::getU8(uint64_t *offset_ptr, uint8_t *dst,
85 uint32_t count) const {
86 return getUs<uint8_t>(offset_ptr, dst, count, nullptr);
87}
88
89uint8_t *DataExtractor::getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const {
90 return getUs<uint8_t>(&C.Offset, Dst, Count, &C.Err);
91}
92
94 return getU<uint16_t>(offset_ptr, Err);
95}
96
98 uint32_t count) const {
99 return getUs<uint16_t>(offset_ptr, dst, count, nullptr);
100}
101
103 uint24_t ExtractedVal = getU<uint24_t>(OffsetPtr, Err);
104 // The 3 bytes are in the correct byte order for the host.
105 return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
106}
107
109 return getU<uint32_t>(offset_ptr, Err);
110}
111
113 uint32_t count) const {
114 return getUs<uint32_t>(offset_ptr, dst, count, nullptr);
115}
116
118 return getU<uint64_t>(offset_ptr, Err);
119}
120
122 uint32_t count) const {
123 return getUs<uint64_t>(offset_ptr, dst, count, nullptr);
124}
125
127 llvm::Error *Err) const {
128 switch (byte_size) {
129 case 1:
130 return getU8(offset_ptr, Err);
131 case 2:
132 return getU16(offset_ptr, Err);
133 case 4:
134 return getU32(offset_ptr, Err);
135 case 8:
136 return getU64(offset_ptr, Err);
137 }
138 llvm_unreachable("getUnsigned unhandled case!");
139}
140
141int64_t
142DataExtractor::getSigned(uint64_t *offset_ptr, uint32_t byte_size) const {
143 switch (byte_size) {
144 case 1:
145 return (int8_t)getU8(offset_ptr);
146 case 2:
147 return (int16_t)getU16(offset_ptr);
148 case 4:
149 return (int32_t)getU32(offset_ptr);
150 case 8:
151 return (int64_t)getU64(offset_ptr);
152 }
153 llvm_unreachable("getSigned unhandled case!");
154}
155
157 ErrorAsOutParameter ErrAsOut(Err);
158 if (isError(Err))
159 return StringRef();
160
161 uint64_t Start = *OffsetPtr;
162 StringRef::size_type Pos = Data.find('\0', Start);
163 if (Pos != StringRef::npos) {
164 *OffsetPtr = Pos + 1;
165 return StringRef(Data.data() + Start, Pos - Start);
166 }
167 if (Err)
169 "no null terminated string at offset 0x%" PRIx64,
170 Start);
171 return StringRef();
172}
173
176 StringRef TrimChars) const {
177 StringRef Bytes(getBytes(OffsetPtr, Length));
178 return Bytes.trim(TrimChars);
179}
180
182 Error *Err) const {
183 ErrorAsOutParameter ErrAsOut(Err);
184 if (isError(Err))
185 return StringRef();
186
187 if (!prepareRead(*OffsetPtr, Length, Err))
188 return StringRef();
189
190 StringRef Result = Data.substr(*OffsetPtr, Length);
191 *OffsetPtr += Length;
192 return Result;
193}
194
195template <typename T>
196static T getLEB128(StringRef Data, uint64_t *OffsetPtr, Error *Err,
197 T (&Decoder)(const uint8_t *p, unsigned *n,
198 const uint8_t *end, const char **error)) {
199 ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(Data);
200 assert(*OffsetPtr <= Bytes.size());
201 ErrorAsOutParameter ErrAsOut(Err);
202 if (isError(Err))
203 return T();
204
205 const char *error = nullptr;
206 unsigned bytes_read;
207 T result =
208 Decoder(Bytes.data() + *OffsetPtr, &bytes_read, Bytes.end(), &error);
209 if (error) {
210 if (Err)
212 "unable to decode LEB128 at offset 0x%8.8" PRIx64
213 ": %s",
214 *OffsetPtr, error);
215 return T();
216 }
217 *OffsetPtr += bytes_read;
218 return result;
219}
220
222 return getLEB128(Data, offset_ptr, Err, decodeULEB128);
223}
224
225int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr, Error *Err) const {
226 return getLEB128(Data, offset_ptr, Err, decodeSLEB128);
227}
228
230 ErrorAsOutParameter ErrAsOut(&C.Err);
231 if (isError(&C.Err))
232 return;
233
234 if (prepareRead(C.Offset, Length, &C.Err))
235 C.Offset += Length;
236}
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())
This file contains some functions that are useful when dealing with strings.
#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:154
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
const T * data() const
Definition: ArrayRef.h:162
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:1102
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
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:567
size_t size_type
Definition: StringRef.h:56
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:293
StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
Definition: StringRef.h:811
static constexpr size_t npos
Definition: StringRef.h:52
#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:237
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:29
void swapByteOrder(T &Value)
Definition: SwapByteOrder.h:61
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
@ Length
Definition: DWP.cpp:456
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:131
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:165
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1244
@ 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:1923
An auxiliary type to facilitate extraction of 3-byte entities.
Definition: DataExtractor.h:19
uint32_t getAsUint32(bool IsLittleEndian) const
Definition: DataExtractor.h:27