LLVM  10.0.0svn
DataExtractor.h
Go to the documentation of this file.
1 //===-- DataExtractor.h -----------------------------------------*- C++ -*-===//
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 
9 #ifndef LLVM_SUPPORT_DATAEXTRACTOR_H
10 #define LLVM_SUPPORT_DATAEXTRACTOR_H
11 
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/Support/DataTypes.h"
14 #include "llvm/Support/Error.h"
15 
16 namespace llvm {
17 
18 /// An auxiliary type to facilitate extraction of 3-byte entities.
19 struct Uint24 {
20  uint8_t Bytes[3];
21  Uint24(uint8_t U) {
22  Bytes[0] = Bytes[1] = Bytes[2] = U;
23  }
24  Uint24(uint8_t U0, uint8_t U1, uint8_t U2) {
25  Bytes[0] = U0; Bytes[1] = U1; Bytes[2] = U2;
26  }
27  uint32_t getAsUint32(bool IsLittleEndian) const {
28  int LoIx = IsLittleEndian ? 0 : 2;
29  return Bytes[LoIx] + (Bytes[1] << 8) + (Bytes[2-LoIx] << 16);
30  }
31 };
32 
33 using uint24_t = Uint24;
34 static_assert(sizeof(uint24_t) == 3, "sizeof(uint24_t) != 3");
35 
36 /// Needed by swapByteOrder().
38  return uint24_t(C.Bytes[2], C.Bytes[1], C.Bytes[0]);
39 }
40 
43  uint8_t IsLittleEndian;
44  uint8_t AddressSize;
45 public:
46  /// A class representing a position in a DataExtractor, as well as any error
47  /// encountered during extraction. It enables one to extract a sequence of
48  /// values without error-checking and then checking for errors in bulk at the
49  /// end. The class holds an Error object, so failing to check the result of
50  /// the parse will result in a runtime error. The error flag is sticky and
51  /// will cause all subsequent extraction functions to fail without even
52  /// attempting to parse and without updating the Cursor offset. After clearing
53  /// the error flag, one can again use the Cursor object for parsing.
54  class Cursor {
55  uint64_t Offset;
56  Error Err;
57 
58  friend class DataExtractor;
59 
60  public:
61  /// Construct a cursor for extraction from the given offset.
62  explicit Cursor(uint64_t Offset) : Offset(Offset), Err(Error::success()) {}
63 
64  /// Checks whether the cursor is valid (i.e. no errors were encountered). In
65  /// case of errors, this does not clear the error flag -- one must call
66  /// takeError() instead.
67  explicit operator bool() { return !Err; }
68 
69  /// Return the current position of this Cursor. In the error state this is
70  /// the position of the Cursor before the first error was encountered.
71  uint64_t tell() const { return Offset; }
72 
73  /// Return error contained inside this Cursor, if any. Clears the internal
74  /// Cursor state.
75  Error takeError() { return std::move(Err); }
76  };
77 
78  /// Construct with a buffer that is owned by the caller.
79  ///
80  /// This constructor allows us to use data that is owned by the
81  /// caller. The data must stay around as long as this object is
82  /// valid.
83  DataExtractor(StringRef Data, bool IsLittleEndian, uint8_t AddressSize)
84  : Data(Data), IsLittleEndian(IsLittleEndian), AddressSize(AddressSize) {}
85  DataExtractor(ArrayRef<uint8_t> Data, bool IsLittleEndian,
86  uint8_t AddressSize)
87  : Data(StringRef(reinterpret_cast<const char *>(Data.data()),
88  Data.size())),
89  IsLittleEndian(IsLittleEndian), AddressSize(AddressSize) {}
90 
91  /// Get the data pointed to by this extractor.
92  StringRef getData() const { return Data; }
93  /// Get the endianness for this extractor.
94  bool isLittleEndian() const { return IsLittleEndian; }
95  /// Get the address size for this extractor.
96  uint8_t getAddressSize() const { return AddressSize; }
97  /// Set the address size for this extractor.
98  void setAddressSize(uint8_t Size) { AddressSize = Size; }
99 
100  /// Extract a C string from \a *offset_ptr.
101  ///
102  /// Returns a pointer to a C String from the data at the offset
103  /// pointed to by \a offset_ptr. A variable length NULL terminated C
104  /// string will be extracted and the \a offset_ptr will be
105  /// updated with the offset of the byte that follows the NULL
106  /// terminator byte.
107  ///
108  /// @param[in,out] offset_ptr
109  /// A pointer to an offset within the data that will be advanced
110  /// by the appropriate number of bytes if the value is extracted
111  /// correctly. If the offset is out of bounds or there are not
112  /// enough bytes to extract this value, the offset will be left
113  /// unmodified.
114  ///
115  /// @return
116  /// A pointer to the C string value in the data. If the offset
117  /// pointed to by \a offset_ptr is out of bounds, or if the
118  /// offset plus the length of the C string is out of bounds,
119  /// NULL will be returned.
120  const char *getCStr(uint64_t *offset_ptr) const;
121 
122  /// Extract a C string from \a *offset_ptr.
123  ///
124  /// Returns a StringRef for the C String from the data at the offset
125  /// pointed to by \a offset_ptr. A variable length NULL terminated C
126  /// string will be extracted and the \a offset_ptr will be
127  /// updated with the offset of the byte that follows the NULL
128  /// terminator byte.
129  ///
130  /// \param[in,out] offset_ptr
131  /// A pointer to an offset within the data that will be advanced
132  /// by the appropriate number of bytes if the value is extracted
133  /// correctly. If the offset is out of bounds or there are not
134  /// enough bytes to extract this value, the offset will be left
135  /// unmodified.
136  ///
137  /// \return
138  /// A StringRef for the C string value in the data. If the offset
139  /// pointed to by \a offset_ptr is out of bounds, or if the
140  /// offset plus the length of the C string is out of bounds,
141  /// a default-initialized StringRef will be returned.
142  StringRef getCStrRef(uint64_t *offset_ptr) const;
143 
144  /// Extract an unsigned integer of size \a byte_size from \a
145  /// *offset_ptr.
146  ///
147  /// Extract a single unsigned integer value and update the offset
148  /// pointed to by \a offset_ptr. The size of the extracted integer
149  /// is specified by the \a byte_size argument. \a byte_size should
150  /// have a value greater than or equal to one and less than or equal
151  /// to eight since the return value is 64 bits wide. Any
152  /// \a byte_size values less than 1 or greater than 8 will result in
153  /// nothing being extracted, and zero being returned.
154  ///
155  /// @param[in,out] offset_ptr
156  /// A pointer to an offset within the data that will be advanced
157  /// by the appropriate number of bytes if the value is extracted
158  /// correctly. If the offset is out of bounds or there are not
159  /// enough bytes to extract this value, the offset will be left
160  /// unmodified.
161  ///
162  /// @param[in] byte_size
163  /// The size in byte of the integer to extract.
164  ///
165  /// @param[in,out] Err
166  /// A pointer to an Error object. Upon return the Error object is set to
167  /// indicate the result (success/failure) of the function. If the Error
168  /// object is already set when calling this function, no extraction is
169  /// performed.
170  ///
171  /// @return
172  /// The unsigned integer value that was extracted, or zero on
173  /// failure.
174  uint64_t getUnsigned(uint64_t *offset_ptr, uint32_t byte_size,
175  Error *Err = nullptr) const;
176 
177  /// Extract an unsigned integer of the given size from the location given by
178  /// the cursor. In case of an extraction error, or if the cursor is already in
179  /// an error state, zero is returned.
180  uint64_t getUnsigned(Cursor &C, uint32_t Size) const {
181  return getUnsigned(&C.Offset, Size, &C.Err);
182  }
183 
184  /// Extract an signed integer of size \a byte_size from \a *offset_ptr.
185  ///
186  /// Extract a single signed integer value (sign extending if required)
187  /// and update the offset pointed to by \a offset_ptr. The size of
188  /// the extracted integer is specified by the \a byte_size argument.
189  /// \a byte_size should have a value greater than or equal to one
190  /// and less than or equal to eight since the return value is 64
191  /// bits wide. Any \a byte_size values less than 1 or greater than
192  /// 8 will result in nothing being extracted, and zero being returned.
193  ///
194  /// @param[in,out] offset_ptr
195  /// A pointer to an offset within the data that will be advanced
196  /// by the appropriate number of bytes if the value is extracted
197  /// correctly. If the offset is out of bounds or there are not
198  /// enough bytes to extract this value, the offset will be left
199  /// unmodified.
200  ///
201  /// @param[in] size
202  /// The size in bytes of the integer to extract.
203  ///
204  /// @return
205  /// The sign extended signed integer value that was extracted,
206  /// or zero on failure.
207  int64_t getSigned(uint64_t *offset_ptr, uint32_t size) const;
208 
209  //------------------------------------------------------------------
210  /// Extract an pointer from \a *offset_ptr.
211  ///
212  /// Extract a single pointer from the data and update the offset
213  /// pointed to by \a offset_ptr. The size of the extracted pointer
214  /// is \a getAddressSize(), so the address size has to be
215  /// set correctly prior to extracting any pointer values.
216  ///
217  /// @param[in,out] offset_ptr
218  /// A pointer to an offset within the data that will be advanced
219  /// by the appropriate number of bytes if the value is extracted
220  /// correctly. If the offset is out of bounds or there are not
221  /// enough bytes to extract this value, the offset will be left
222  /// unmodified.
223  ///
224  /// @return
225  /// The extracted pointer value as a 64 integer.
226  uint64_t getAddress(uint64_t *offset_ptr) const {
227  return getUnsigned(offset_ptr, AddressSize);
228  }
229 
230  /// Extract a pointer-sized unsigned integer from the location given by the
231  /// cursor. In case of an extraction error, or if the cursor is already in
232  /// an error state, zero is returned.
233  uint64_t getAddress(Cursor &C) const { return getUnsigned(C, AddressSize); }
234 
235  /// Extract a uint8_t value from \a *offset_ptr.
236  ///
237  /// Extract a single uint8_t from the binary data at the offset
238  /// pointed to by \a offset_ptr, and advance the offset on success.
239  ///
240  /// @param[in,out] offset_ptr
241  /// A pointer to an offset within the data that will be advanced
242  /// by the appropriate number of bytes if the value is extracted
243  /// correctly. If the offset is out of bounds or there are not
244  /// enough bytes to extract this value, the offset will be left
245  /// unmodified.
246  ///
247  /// @param[in,out] Err
248  /// A pointer to an Error object. Upon return the Error object is set to
249  /// indicate the result (success/failure) of the function. If the Error
250  /// object is already set when calling this function, no extraction is
251  /// performed.
252  ///
253  /// @return
254  /// The extracted uint8_t value.
255  uint8_t getU8(uint64_t *offset_ptr, Error *Err = nullptr) const;
256 
257  /// Extract a single uint8_t value from the location given by the cursor. In
258  /// case of an extraction error, or if the cursor is already in an error
259  /// state, zero is returned.
260  uint8_t getU8(Cursor &C) const { return getU8(&C.Offset, &C.Err); }
261 
262  /// Extract \a count uint8_t values from \a *offset_ptr.
263  ///
264  /// Extract \a count uint8_t values from the binary data at the
265  /// offset pointed to by \a offset_ptr, and advance the offset on
266  /// success. The extracted values are copied into \a dst.
267  ///
268  /// @param[in,out] offset_ptr
269  /// A pointer to an offset within the data that will be advanced
270  /// by the appropriate number of bytes if the value is extracted
271  /// correctly. If the offset is out of bounds or there are not
272  /// enough bytes to extract this value, the offset will be left
273  /// unmodified.
274  ///
275  /// @param[out] dst
276  /// A buffer to copy \a count uint8_t values into. \a dst must
277  /// be large enough to hold all requested data.
278  ///
279  /// @param[in] count
280  /// The number of uint8_t values to extract.
281  ///
282  /// @return
283  /// \a dst if all values were properly extracted and copied,
284  /// NULL otherise.
285  uint8_t *getU8(uint64_t *offset_ptr, uint8_t *dst, uint32_t count) const;
286 
287  /// Extract \a Count uint8_t values from the location given by the cursor and
288  /// store them into the destination buffer. In case of an extraction error, or
289  /// if the cursor is already in an error state, a nullptr is returned and the
290  /// destination buffer is left unchanged.
291  uint8_t *getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const;
292 
293  /// Extract \a Count uint8_t values from the location given by the cursor and
294  /// store them into the destination vector. The vector is resized to fit the
295  /// extracted data. In case of an extraction error, or if the cursor is
296  /// already in an error state, the destination vector is left unchanged and
297  /// cursor is placed into an error state.
298  void getU8(Cursor &C, SmallVectorImpl<uint8_t> &Dst, uint32_t Count) const {
299  if (isValidOffsetForDataOfSize(C.Offset, Count))
300  Dst.resize(Count);
301 
302  // This relies on the fact that getU8 will not attempt to write to the
303  // buffer if isValidOffsetForDataOfSize(C.Offset, Count) is false.
304  getU8(C, Dst.data(), Count);
305  }
306 
307  //------------------------------------------------------------------
308  /// Extract a uint16_t value from \a *offset_ptr.
309  ///
310  /// Extract a single uint16_t from the binary data at the offset
311  /// pointed to by \a offset_ptr, and update the offset on success.
312  ///
313  /// @param[in,out] offset_ptr
314  /// A pointer to an offset within the data that will be advanced
315  /// by the appropriate number of bytes if the value is extracted
316  /// correctly. If the offset is out of bounds or there are not
317  /// enough bytes to extract this value, the offset will be left
318  /// unmodified.
319  ///
320  /// @param[in,out] Err
321  /// A pointer to an Error object. Upon return the Error object is set to
322  /// indicate the result (success/failure) of the function. If the Error
323  /// object is already set when calling this function, no extraction is
324  /// performed.
325  ///
326  /// @return
327  /// The extracted uint16_t value.
328  //------------------------------------------------------------------
329  uint16_t getU16(uint64_t *offset_ptr, Error *Err = nullptr) const;
330 
331  /// Extract a single uint16_t value from the location given by the cursor. In
332  /// case of an extraction error, or if the cursor is already in an error
333  /// state, zero is returned.
334  uint16_t getU16(Cursor &C) const { return getU16(&C.Offset, &C.Err); }
335 
336  /// Extract \a count uint16_t values from \a *offset_ptr.
337  ///
338  /// Extract \a count uint16_t values from the binary data at the
339  /// offset pointed to by \a offset_ptr, and advance the offset on
340  /// success. The extracted values are copied into \a dst.
341  ///
342  /// @param[in,out] offset_ptr
343  /// A pointer to an offset within the data that will be advanced
344  /// by the appropriate number of bytes if the value is extracted
345  /// correctly. If the offset is out of bounds or there are not
346  /// enough bytes to extract this value, the offset will be left
347  /// unmodified.
348  ///
349  /// @param[out] dst
350  /// A buffer to copy \a count uint16_t values into. \a dst must
351  /// be large enough to hold all requested data.
352  ///
353  /// @param[in] count
354  /// The number of uint16_t values to extract.
355  ///
356  /// @return
357  /// \a dst if all values were properly extracted and copied,
358  /// NULL otherise.
359  uint16_t *getU16(uint64_t *offset_ptr, uint16_t *dst, uint32_t count) const;
360 
361  /// Extract a 24-bit unsigned value from \a *offset_ptr and return it
362  /// in a uint32_t.
363  ///
364  /// Extract 3 bytes from the binary data at the offset pointed to by
365  /// \a offset_ptr, construct a uint32_t from them and update the offset
366  /// on success.
367  ///
368  /// @param[in,out] offset_ptr
369  /// A pointer to an offset within the data that will be advanced
370  /// by the 3 bytes if the value is extracted correctly. If the offset
371  /// is out of bounds or there are not enough bytes to extract this value,
372  /// the offset will be left unmodified.
373  ///
374  /// @return
375  /// The extracted 24-bit value represented in a uint32_t.
376  uint32_t getU24(uint64_t *offset_ptr) const;
377 
378  /// Extract a uint32_t value from \a *offset_ptr.
379  ///
380  /// Extract a single uint32_t from the binary data at the offset
381  /// pointed to by \a offset_ptr, and update the offset on success.
382  ///
383  /// @param[in,out] offset_ptr
384  /// A pointer to an offset within the data that will be advanced
385  /// by the appropriate number of bytes if the value is extracted
386  /// correctly. If the offset is out of bounds or there are not
387  /// enough bytes to extract this value, the offset will be left
388  /// unmodified.
389  ///
390  /// @param[in,out] Err
391  /// A pointer to an Error object. Upon return the Error object is set to
392  /// indicate the result (success/failure) of the function. If the Error
393  /// object is already set when calling this function, no extraction is
394  /// performed.
395  ///
396  /// @return
397  /// The extracted uint32_t value.
398  uint32_t getU32(uint64_t *offset_ptr, Error *Err = nullptr) const;
399 
400  /// Extract a single uint32_t value from the location given by the cursor. In
401  /// case of an extraction error, or if the cursor is already in an error
402  /// state, zero is returned.
403  uint32_t getU32(Cursor &C) const { return getU32(&C.Offset, &C.Err); }
404 
405  /// Extract \a count uint32_t values from \a *offset_ptr.
406  ///
407  /// Extract \a count uint32_t values from the binary data at the
408  /// offset pointed to by \a offset_ptr, and advance the offset on
409  /// success. The extracted values are copied into \a dst.
410  ///
411  /// @param[in,out] offset_ptr
412  /// A pointer to an offset within the data that will be advanced
413  /// by the appropriate number of bytes if the value is extracted
414  /// correctly. If the offset is out of bounds or there are not
415  /// enough bytes to extract this value, the offset will be left
416  /// unmodified.
417  ///
418  /// @param[out] dst
419  /// A buffer to copy \a count uint32_t values into. \a dst must
420  /// be large enough to hold all requested data.
421  ///
422  /// @param[in] count
423  /// The number of uint32_t values to extract.
424  ///
425  /// @return
426  /// \a dst if all values were properly extracted and copied,
427  /// NULL otherise.
428  uint32_t *getU32(uint64_t *offset_ptr, uint32_t *dst, uint32_t count) const;
429 
430  /// Extract a uint64_t value from \a *offset_ptr.
431  ///
432  /// Extract a single uint64_t from the binary data at the offset
433  /// pointed to by \a offset_ptr, and update the offset on success.
434  ///
435  /// @param[in,out] offset_ptr
436  /// A pointer to an offset within the data that will be advanced
437  /// by the appropriate number of bytes if the value is extracted
438  /// correctly. If the offset is out of bounds or there are not
439  /// enough bytes to extract this value, the offset will be left
440  /// unmodified.
441  ///
442  /// @param[in,out] Err
443  /// A pointer to an Error object. Upon return the Error object is set to
444  /// indicate the result (success/failure) of the function. If the Error
445  /// object is already set when calling this function, no extraction is
446  /// performed.
447  ///
448  /// @return
449  /// The extracted uint64_t value.
450  uint64_t getU64(uint64_t *offset_ptr, Error *Err = nullptr) const;
451 
452  /// Extract a single uint64_t value from the location given by the cursor. In
453  /// case of an extraction error, or if the cursor is already in an error
454  /// state, zero is returned.
455  uint64_t getU64(Cursor &C) const { return getU64(&C.Offset, &C.Err); }
456 
457  /// Extract \a count uint64_t values from \a *offset_ptr.
458  ///
459  /// Extract \a count uint64_t values from the binary data at the
460  /// offset pointed to by \a offset_ptr, and advance the offset on
461  /// success. The extracted values are copied into \a dst.
462  ///
463  /// @param[in,out] offset_ptr
464  /// A pointer to an offset within the data that will be advanced
465  /// by the appropriate number of bytes if the value is extracted
466  /// correctly. If the offset is out of bounds or there are not
467  /// enough bytes to extract this value, the offset will be left
468  /// unmodified.
469  ///
470  /// @param[out] dst
471  /// A buffer to copy \a count uint64_t values into. \a dst must
472  /// be large enough to hold all requested data.
473  ///
474  /// @param[in] count
475  /// The number of uint64_t values to extract.
476  ///
477  /// @return
478  /// \a dst if all values were properly extracted and copied,
479  /// NULL otherise.
480  uint64_t *getU64(uint64_t *offset_ptr, uint64_t *dst, uint32_t count) const;
481 
482  /// Extract a signed LEB128 value from \a *offset_ptr.
483  ///
484  /// Extracts an signed LEB128 number from this object's data
485  /// starting at the offset pointed to by \a offset_ptr. The offset
486  /// pointed to by \a offset_ptr will be updated with the offset of
487  /// the byte following the last extracted byte.
488  ///
489  /// @param[in,out] offset_ptr
490  /// A pointer to an offset within the data that will be advanced
491  /// by the appropriate number of bytes if the value is extracted
492  /// correctly. If the offset is out of bounds or there are not
493  /// enough bytes to extract this value, the offset will be left
494  /// unmodified.
495  ///
496  /// @return
497  /// The extracted signed integer value.
498  int64_t getSLEB128(uint64_t *offset_ptr) const;
499 
500  /// Extract a unsigned LEB128 value from \a *offset_ptr.
501  ///
502  /// Extracts an unsigned LEB128 number from this object's data
503  /// starting at the offset pointed to by \a offset_ptr. The offset
504  /// pointed to by \a offset_ptr will be updated with the offset of
505  /// the byte following the last extracted byte.
506  ///
507  /// @param[in,out] offset_ptr
508  /// A pointer to an offset within the data that will be advanced
509  /// by the appropriate number of bytes if the value is extracted
510  /// correctly. If the offset is out of bounds or there are not
511  /// enough bytes to extract this value, the offset will be left
512  /// unmodified.
513  ///
514  /// @param[in,out] Err
515  /// A pointer to an Error object. Upon return the Error object is set to
516  /// indicate the result (success/failure) of the function. If the Error
517  /// object is already set when calling this function, no extraction is
518  /// performed.
519  ///
520  /// @return
521  /// The extracted unsigned integer value.
522  uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err = nullptr) const;
523 
524  /// Extract an unsigned ULEB128 value from the location given by the cursor.
525  /// In case of an extraction error, or if the cursor is already in an error
526  /// state, zero is returned.
527  uint64_t getULEB128(Cursor &C) const { return getULEB128(&C.Offset, &C.Err); }
528 
529  /// Advance the Cursor position by the given number of bytes. No-op if the
530  /// cursor is in an error state.
531  void skip(Cursor &C, uint64_t Length) const;
532 
533  /// Return true iff the cursor is at the end of the buffer, regardless of the
534  /// error state of the cursor. The only way both eof and error states can be
535  /// true is if one attempts a read while the cursor is at the very end of the
536  /// data buffer.
537  bool eof(const Cursor &C) const { return Data.size() == C.Offset; }
538 
539  /// Test the validity of \a offset.
540  ///
541  /// @return
542  /// \b true if \a offset is a valid offset into the data in this
543  /// object, \b false otherwise.
544  bool isValidOffset(uint64_t offset) const { return Data.size() > offset; }
545 
546  /// Test the availability of \a length bytes of data from \a offset.
547  ///
548  /// @return
549  /// \b true if \a offset is a valid offset and there are \a
550  /// length bytes available at that offset, \b false otherwise.
551  bool isValidOffsetForDataOfSize(uint64_t offset, uint64_t length) const {
552  return offset + length >= offset && isValidOffset(offset + length - 1);
553  }
554 
555  /// Test the availability of enough bytes of data for a pointer from
556  /// \a offset. The size of a pointer is \a getAddressSize().
557  ///
558  /// @return
559  /// \b true if \a offset is a valid offset and there are enough
560  /// bytes for a pointer available at that offset, \b false
561  /// otherwise.
562  bool isValidOffsetForAddress(uint64_t offset) const {
563  return isValidOffsetForDataOfSize(offset, AddressSize);
564  }
565 
566 protected:
567  // Make it possible for subclasses to access these fields without making them
568  // public.
569  static uint64_t &getOffset(Cursor &C) { return C.Offset; }
570  static Error &getError(Cursor &C) { return C.Err; }
571 };
572 
573 } // namespace llvm
574 
575 #endif
uint64_t CallInst * C
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Cursor(uint64_t Offset)
Construct a cursor for extraction from the given offset.
Definition: DataExtractor.h:62
uint64_t tell() const
Return the current position of this Cursor.
Definition: DataExtractor.h:71
uint32_t getAsUint32(bool IsLittleEndian) const
Definition: DataExtractor.h:27
DataExtractor(ArrayRef< uint8_t > Data, bool IsLittleEndian, uint8_t AddressSize)
Definition: DataExtractor.h:85
StringRef getData() const
Get the data pointed to by this extractor.
Definition: DataExtractor.h:92
void skip(CollectionType &C)
Definition: YAMLParser.h:388
uint64_t getUnsigned(Cursor &C, uint32_t Size) const
Extract an unsigned integer of the given size from the location given by the cursor.
An auxiliary type to facilitate extraction of 3-byte entities.
Definition: DataExtractor.h:19
Error takeError()
Return error contained inside this Cursor, if any.
Definition: DataExtractor.h:75
void getU8(Cursor &C, SmallVectorImpl< uint8_t > &Dst, uint32_t Count) const
Extract Count uint8_t values from the location given by the cursor and store them into the destinatio...
Uint24(uint8_t U)
Definition: DataExtractor.h:21
static uint64_t & getOffset(Cursor &C)
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
bool isLittleEndian() const
Get the endianness for this extractor.
Definition: DataExtractor.h:94
auto count(R &&Range, const E &Element) -> typename std::iterator_traits< decltype(adl_begin(Range))>::difference_type
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:1231
uint64_t getU64(Cursor &C) const
Extract a single uint64_t value from the location given by the cursor.
uint8_t getAddressSize() const
Get the address size for this extractor.
Definition: DataExtractor.h:96
uint64_t getAddress(Cursor &C) const
Extract a pointer-sized unsigned integer from the location given by the cursor.
DataExtractor(StringRef Data, bool IsLittleEndian, uint8_t AddressSize)
Construct with a buffer that is owned by the caller.
Definition: DataExtractor.h:83
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
Uint24 uint24_t
Definition: DataExtractor.h:33
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1146
bool isValidOffsetForDataOfSize(uint64_t offset, uint64_t length) const
Test the availability of length bytes of data from offset.
bool eof(const Cursor &C) const
Return true iff the cursor is at the end of the buffer, regardless of the error state of the cursor...
uint8_t getU8(Cursor &C) const
Extract a single uint8_t value from the location given by the cursor.
void setAddressSize(uint8_t Size)
Set the address size for this extractor.
Definition: DataExtractor.h:98
bool isValidOffset(uint64_t offset) const
Test the validity of offset.
uint24_t getSwappedBytes(uint24_t C)
Needed by swapByteOrder().
Definition: DataExtractor.h:37
uint64_t getULEB128(Cursor &C) const
Extract an unsigned ULEB128 value from the location given by the cursor.
uint8_t Bytes[3]
Definition: DataExtractor.h:20
pointer data()
Return a pointer to the vector&#39;s buffer, even if empty().
Definition: SmallVector.h:144
uint32_t getU32(Cursor &C) const
Extract a single uint32_t value from the location given by the cursor.
Uint24(uint8_t U0, uint8_t U1, uint8_t U2)
Definition: DataExtractor.h:24
static Error & getError(Cursor &C)
uint32_t Size
Definition: Profile.cpp:46
uint64_t getAddress(uint64_t *offset_ptr) const
Extract an pointer from *offset_ptr.
uint16_t getU16(Cursor &C) const
Extract a single uint16_t value from the location given by the cursor.
aarch64 promote const
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
bool isValidOffsetForAddress(uint64_t offset) const
Test the availability of enough bytes of data for a pointer from offset.
void resize(size_type N)
Definition: SmallVector.h:344