xref: /freebsd/contrib/llvm-project/llvm/include/llvm/Support/DataExtractor.h (revision b13788e396c2b24f88697e7d4a74bab429ef4d0c)
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().
37 inline uint24_t getSwappedBytes(uint24_t C) {
38   return uint24_t(C.Bytes[2], C.Bytes[1], C.Bytes[0]);
39 }
40 
41 class DataExtractor {
42   StringRef Data;
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 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 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   /// Return the number of bytes in the underlying buffer.
567   size_t size() const { return Data.size(); }
568 
569 protected:
570   // Make it possible for subclasses to access these fields without making them
571   // public.
572   static uint64_t &getOffset(Cursor &C) { return C.Offset; }
573   static Error &getError(Cursor &C) { return C.Err; }
574 };
575 
576 } // namespace llvm
577 
578 #endif
579