LLVM  14.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/Host.h"
13 #include "llvm/Support/LEB128.h"
15 
16 using namespace llvm;
17 
18 bool 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 
38 static bool isError(Error *E) { return E && *E; }
39 
40 template <typename T>
41 T 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 
59 template <typename T>
60 T *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 
80 uint8_t DataExtractor::getU8(uint64_t *offset_ptr, llvm::Error *Err) const {
81  return getU<uint8_t>(offset_ptr, Err);
82 }
83 
84 uint8_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 
89 uint8_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 
93 uint16_t DataExtractor::getU16(uint64_t *offset_ptr, llvm::Error *Err) const {
94  return getU<uint16_t>(offset_ptr, Err);
95 }
96 
97 uint16_t *DataExtractor::getU16(uint64_t *offset_ptr, uint16_t *dst,
98  uint32_t count) const {
99  return getUs<uint16_t>(offset_ptr, dst, count, nullptr);
100 }
101 
102 uint32_t DataExtractor::getU24(uint64_t *OffsetPtr, Error *Err) const {
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 
108 uint32_t DataExtractor::getU32(uint64_t *offset_ptr, llvm::Error *Err) const {
109  return getU<uint32_t>(offset_ptr, Err);
110 }
111 
112 uint32_t *DataExtractor::getU32(uint64_t *offset_ptr, uint32_t *dst,
113  uint32_t count) const {
114  return getUs<uint32_t>(offset_ptr, dst, count, nullptr);
115 }
116 
117 uint64_t DataExtractor::getU64(uint64_t *offset_ptr, llvm::Error *Err) const {
118  return getU<uint64_t>(offset_ptr, Err);
119 }
120 
121 uint64_t *DataExtractor::getU64(uint64_t *offset_ptr, uint64_t *dst,
122  uint32_t count) const {
123  return getUs<uint64_t>(offset_ptr, dst, count, nullptr);
124 }
125 
126 uint64_t DataExtractor::getUnsigned(uint64_t *offset_ptr, uint32_t byte_size,
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 
141 int64_t
142 DataExtractor::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 
156 StringRef DataExtractor::getCStrRef(uint64_t *OffsetPtr, Error *Err) const {
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 
175  uint64_t Length,
176  StringRef TrimChars) const {
177  StringRef Bytes(getBytes(OffsetPtr, Length));
178  return Bytes.trim(TrimChars);
179 }
180 
181 StringRef DataExtractor::getBytes(uint64_t *OffsetPtr, uint64_t Length,
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 
195 template <typename T>
196 static 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;
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 
221 uint64_t DataExtractor::getULEB128(uint64_t *offset_ptr, Error *Err) const {
222  return getLEB128(Data, offset_ptr, Err, decodeULEB128);
223 }
224 
225 int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr, Error *Err) const {
226  return getLEB128(Data, offset_ptr, Err, decodeSLEB128);
227 }
228 
229 void DataExtractor::skip(Cursor &C, uint64_t Length) const {
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 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
isError
static bool isError(Error *E)
Definition: DataExtractor.cpp:38
llvm::errc::invalid_argument
@ invalid_argument
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::sys::swapByteOrder
void swapByteOrder(T &Value)
Definition: SwapByteOrder.h:158
llvm::DataExtractor::getSigned
int64_t getSigned(uint64_t *offset_ptr, uint32_t size) const
Extract an signed integer of size byte_size from *offset_ptr.
Definition: DataExtractor.cpp:142
llvm::Uint24
An auxiliary type to facilitate extraction of 3-byte entities.
Definition: DataExtractor.h:19
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
Host.h
llvm::StringRef::find
LLVM_NODISCARD size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:315
ErrorHandling.h
SwapByteOrder.h
Errc.h
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
error
#define error(X)
Definition: SymbolRecordMapping.cpp:14
T
#define T
Definition: Mips16ISelLowering.cpp:341
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::DataExtractor::getU64
uint64_t getU64(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint64_t value from *offset_ptr.
Definition: DataExtractor.cpp:117
llvm::DataExtractor::skip
void skip(Cursor &C, uint64_t Length) const
Advance the Cursor position by the given number of bytes.
Definition: DataExtractor.cpp:229
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
size_t
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:162
result
It looks like we only need to define PPCfmarto for these because according to these instructions perform RTO on fma s result
Definition: README_P9.txt:256
llvm::StringRef::substr
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:611
llvm::DataExtractor::getULEB128
uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err=nullptr) const
Extract a unsigned LEB128 value from *offset_ptr.
Definition: DataExtractor.cpp:221
llvm::decodeULEB128
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
llvm::DataExtractor::getBytes
StringRef getBytes(uint64_t *OffsetPtr, uint64_t Length, Error *Err=nullptr) const
Extract a fixed number of bytes from the specified offset.
Definition: DataExtractor.cpp:181
llvm::DataExtractor::getFixedLengthString
StringRef getFixedLengthString(uint64_t *OffsetPtr, uint64_t Length, StringRef TrimChars={"\0", 1}) const
Extract a fixed length string from *OffsetPtr and consume Length bytes.
Definition: DataExtractor.cpp:174
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
getLEB128
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))
Definition: DataExtractor.cpp:196
llvm::ErrorAsOutParameter
Helper for Errors used as out-parameters.
Definition: Error.h:1089
llvm::errc::illegal_byte_sequence
@ illegal_byte_sequence
llvm::StringRef::trim
LLVM_NODISCARD StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
Definition: StringRef.h:870
val
The initial backend is deliberately restricted to z10 We should add support for later architectures at some point If an asm ties an i32 r result to an i64 the input will be treated as an leaving the upper bits uninitialised For i64 store i32 val
Definition: README.txt:15
llvm::count
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:1630
llvm::DataExtractor::isValidOffsetForDataOfSize
bool isValidOffsetForDataOfSize(uint64_t offset, uint64_t length) const
Test the availability of length bytes of data from offset.
Definition: DataExtractor.h:669
LEB128.h
llvm::Uint24::getAsUint32
uint32_t getAsUint32(bool IsLittleEndian) const
Definition: DataExtractor.h:27
llvm::DataExtractor::getUnsigned
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.
Definition: DataExtractor.cpp:126
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
llvm::DataExtractor::Cursor
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
llvm::DataExtractor::getU32
uint32_t getU32(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint32_t value from *offset_ptr.
Definition: DataExtractor.cpp:108
llvm::ArrayRef< uint8_t >
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
uint32_t
llvm::DataExtractor::getU24
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.
Definition: DataExtractor.cpp:102
llvm::DataExtractor::getU8
uint8_t getU8(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint8_t value from *offset_ptr.
Definition: DataExtractor.cpp:80
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1231
uint16_t
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
DataExtractor.h
llvm::DataExtractor::getCStrRef
StringRef getCStrRef(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
Definition: DataExtractor.cpp:156
llvm::decodeSLEB128
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
llvm::sys::IsLittleEndianHost
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:101
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:149
n
The same transformation can work with an even modulo with the addition of a and shrink the compare RHS by the same amount Unless the target supports that transformation probably isn t worthwhile The transformation can also easily be made to work with non zero equality for n
Definition: README.txt:685
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
llvm::DataExtractor::getU16
uint16_t getU16(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint16_t value from *offset_ptr.
Definition: DataExtractor.cpp:93
llvm::DataExtractor::getSLEB128
int64_t getSLEB128(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a signed LEB128 value from *offset_ptr.
Definition: DataExtractor.cpp:225