• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- DataExtractor.cpp -------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/Support/DataExtractor.h"
11 #include "llvm/Support/ErrorHandling.h"
12 #include "llvm/Support/Host.h"
13 #include "llvm/Support/SwapByteOrder.h"
14 using namespace llvm;
15 
16 template <typename T>
getU(uint32_t * offset_ptr,const DataExtractor * de,bool isLittleEndian,const char * Data)17 static T getU(uint32_t *offset_ptr, const DataExtractor *de,
18               bool isLittleEndian, const char *Data) {
19   T val = 0;
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);
25 
26     // Advance the offset
27     *offset_ptr += sizeof(val);
28   }
29   return val;
30 }
31 
32 template <typename T>
getUs(uint32_t * offset_ptr,T * dst,uint32_t count,const DataExtractor * de,bool isLittleEndian,const char * Data)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;
36 
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);
41     // Advance the offset
42     *offset_ptr = offset;
43     // Return a non-NULL pointer to the converted data as an indicator of
44     // success
45     return dst;
46   }
47   return nullptr;
48 }
49 
getU8(uint32_t * offset_ptr) const50 uint8_t DataExtractor::getU8(uint32_t *offset_ptr) const {
51   return getU<uint8_t>(offset_ptr, this, IsLittleEndian, Data.data());
52 }
53 
54 uint8_t *
getU8(uint32_t * offset_ptr,uint8_t * dst,uint32_t count) const55 DataExtractor::getU8(uint32_t *offset_ptr, uint8_t *dst, uint32_t count) const {
56   return getUs<uint8_t>(offset_ptr, dst, count, this, IsLittleEndian,
57                        Data.data());
58 }
59 
60 
getU16(uint32_t * offset_ptr) const61 uint16_t DataExtractor::getU16(uint32_t *offset_ptr) const {
62   return getU<uint16_t>(offset_ptr, this, IsLittleEndian, Data.data());
63 }
64 
getU16(uint32_t * offset_ptr,uint16_t * dst,uint32_t count) const65 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,
68                         Data.data());
69 }
70 
getU24(uint32_t * offset_ptr) const71 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);
76 }
77 
getU32(uint32_t * offset_ptr) const78 uint32_t DataExtractor::getU32(uint32_t *offset_ptr) const {
79   return getU<uint32_t>(offset_ptr, this, IsLittleEndian, Data.data());
80 }
81 
getU32(uint32_t * offset_ptr,uint32_t * dst,uint32_t count) const82 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,
85                         Data.data());
86 }
87 
getU64(uint32_t * offset_ptr) const88 uint64_t DataExtractor::getU64(uint32_t *offset_ptr) const {
89   return getU<uint64_t>(offset_ptr, this, IsLittleEndian, Data.data());
90 }
91 
getU64(uint32_t * offset_ptr,uint64_t * dst,uint32_t count) const92 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,
95                         Data.data());
96 }
97 
98 uint64_t
getUnsigned(uint32_t * offset_ptr,uint32_t byte_size) const99 DataExtractor::getUnsigned(uint32_t *offset_ptr, uint32_t byte_size) const {
100   switch (byte_size) {
101   case 1:
102     return getU8(offset_ptr);
103   case 2:
104     return getU16(offset_ptr);
105   case 4:
106     return getU32(offset_ptr);
107   case 8:
108     return getU64(offset_ptr);
109   }
110   llvm_unreachable("getUnsigned unhandled case!");
111 }
112 
113 int64_t
getSigned(uint32_t * offset_ptr,uint32_t byte_size) const114 DataExtractor::getSigned(uint32_t *offset_ptr, uint32_t byte_size) const {
115   switch (byte_size) {
116   case 1:
117     return (int8_t)getU8(offset_ptr);
118   case 2:
119     return (int16_t)getU16(offset_ptr);
120   case 4:
121     return (int32_t)getU32(offset_ptr);
122   case 8:
123     return (int64_t)getU64(offset_ptr);
124   }
125   llvm_unreachable("getSigned unhandled case!");
126 }
127 
getCStr(uint32_t * offset_ptr) const128 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;
134   }
135   return nullptr;
136 }
137 
getCStrRef(uint32_t * OffsetPtr) const138 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);
144   }
145   return StringRef();
146 }
147 
getULEB128(uint32_t * offset_ptr) const148 uint64_t DataExtractor::getULEB128(uint32_t *offset_ptr) const {
149   uint64_t result = 0;
150   if (Data.empty())
151     return 0;
152 
153   unsigned shift = 0;
154   uint32_t offset = *offset_ptr;
155   uint8_t byte = 0;
156 
157   while (isValidOffset(offset)) {
158     byte = Data[offset++];
159     result |= uint64_t(byte & 0x7f) << shift;
160     shift += 7;
161     if ((byte & 0x80) == 0)
162       break;
163   }
164 
165   *offset_ptr = offset;
166   return result;
167 }
168 
getSLEB128(uint32_t * offset_ptr) const169 int64_t DataExtractor::getSLEB128(uint32_t *offset_ptr) const {
170   int64_t result = 0;
171   if (Data.empty())
172     return 0;
173 
174   unsigned shift = 0;
175   uint32_t offset = *offset_ptr;
176   uint8_t byte = 0;
177 
178   while (isValidOffset(offset)) {
179     byte = Data[offset++];
180     result |= uint64_t(byte & 0x7f) << shift;
181     shift += 7;
182     if ((byte & 0x80) == 0)
183       break;
184   }
185 
186   // Sign bit of byte is 2nd high order bit (0x40)
187   if (shift < 64 && (byte & 0x40))
188     result |= -(1ULL << shift);
189 
190   *offset_ptr = offset;
191   return result;
192 }
193