1 //===-- DataExtractor.cpp -------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/Support/DataExtractor.h"
11 #include "llvm/Support/ErrorHandling.h"
12 #include "llvm/Support/Host.h"
13 #include "llvm/Support/SwapByteOrder.h"
17 static T getU(uint32_t *offset_ptr, const DataExtractor *de,
18 bool isLittleEndian, const char *Data) {
20 uint32_t offset = *offset_ptr;
21 if (de->isValidOffsetForDataOfSize(offset, sizeof(val))) {
22 std::memcpy(&val, &Data[offset], sizeof(val));
23 if (sys::IsLittleEndianHost != isLittleEndian)
24 sys::swapByteOrder(val);
27 *offset_ptr += sizeof(val);
33 static T *getUs(uint32_t *offset_ptr, T *dst, uint32_t count,
34 const DataExtractor *de, bool isLittleEndian, const char *Data){
35 uint32_t offset = *offset_ptr;
37 if (count > 0 && de->isValidOffsetForDataOfSize(offset, sizeof(*dst)*count)) {
38 for (T *value_ptr = dst, *end = dst + count; value_ptr != end;
39 ++value_ptr, offset += sizeof(*dst))
40 *value_ptr = getU<T>(offset_ptr, de, isLittleEndian, Data);
43 // Return a non-NULL pointer to the converted data as an indicator of
50 uint8_t DataExtractor::getU8(uint32_t *offset_ptr) const {
51 return getU<uint8_t>(offset_ptr, this, IsLittleEndian, Data.data());
55 DataExtractor::getU8(uint32_t *offset_ptr, uint8_t *dst, uint32_t count) const {
56 return getUs<uint8_t>(offset_ptr, dst, count, this, IsLittleEndian,
61 uint16_t DataExtractor::getU16(uint32_t *offset_ptr) const {
62 return getU<uint16_t>(offset_ptr, this, IsLittleEndian, Data.data());
65 uint16_t *DataExtractor::getU16(uint32_t *offset_ptr, uint16_t *dst,
66 uint32_t count) const {
67 return getUs<uint16_t>(offset_ptr, dst, count, this, IsLittleEndian,
71 uint32_t DataExtractor::getU24(uint32_t *offset_ptr) const {
72 uint24_t ExtractedVal =
73 getU<uint24_t>(offset_ptr, this, IsLittleEndian, Data.data());
74 // The 3 bytes are in the correct byte order for the host.
75 return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
78 uint32_t DataExtractor::getU32(uint32_t *offset_ptr) const {
79 return getU<uint32_t>(offset_ptr, this, IsLittleEndian, Data.data());
82 uint32_t *DataExtractor::getU32(uint32_t *offset_ptr, uint32_t *dst,
83 uint32_t count) const {
84 return getUs<uint32_t>(offset_ptr, dst, count, this, IsLittleEndian,
88 uint64_t DataExtractor::getU64(uint32_t *offset_ptr) const {
89 return getU<uint64_t>(offset_ptr, this, IsLittleEndian, Data.data());
92 uint64_t *DataExtractor::getU64(uint32_t *offset_ptr, uint64_t *dst,
93 uint32_t count) const {
94 return getUs<uint64_t>(offset_ptr, dst, count, this, IsLittleEndian,
99 DataExtractor::getUnsigned(uint32_t *offset_ptr, uint32_t byte_size) const {
102 return getU8(offset_ptr);
104 return getU16(offset_ptr);
106 return getU32(offset_ptr);
108 return getU64(offset_ptr);
110 llvm_unreachable("getUnsigned unhandled case!");
114 DataExtractor::getSigned(uint32_t *offset_ptr, uint32_t byte_size) const {
117 return (int8_t)getU8(offset_ptr);
119 return (int16_t)getU16(offset_ptr);
121 return (int32_t)getU32(offset_ptr);
123 return (int64_t)getU64(offset_ptr);
125 llvm_unreachable("getSigned unhandled case!");
128 const char *DataExtractor::getCStr(uint32_t *offset_ptr) const {
129 uint32_t offset = *offset_ptr;
130 StringRef::size_type pos = Data.find('\0', offset);
131 if (pos != StringRef::npos) {
132 *offset_ptr = pos + 1;
133 return Data.data() + offset;
138 StringRef DataExtractor::getCStrRef(uint32_t *OffsetPtr) const {
139 uint32_t Start = *OffsetPtr;
140 StringRef::size_type Pos = Data.find('\0', Start);
141 if (Pos != StringRef::npos) {
142 *OffsetPtr = Pos + 1;
143 return StringRef(Data.data() + Start, Pos - Start);
148 uint64_t DataExtractor::getULEB128(uint32_t *offset_ptr) const {
154 uint32_t offset = *offset_ptr;
157 while (isValidOffset(offset)) {
158 byte = Data[offset++];
159 result |= uint64_t(byte & 0x7f) << shift;
161 if ((byte & 0x80) == 0)
165 *offset_ptr = offset;
169 int64_t DataExtractor::getSLEB128(uint32_t *offset_ptr) const {
175 uint32_t offset = *offset_ptr;
178 while (isValidOffset(offset)) {
179 byte = Data[offset++];
180 result |= uint64_t(byte & 0x7f) << shift;
182 if ((byte & 0x80) == 0)
186 // Sign bit of byte is 2nd high order bit (0x40)
187 if (shift < 64 && (byte & 0x40))
188 result |= -(1ULL << shift);
190 *offset_ptr = offset;