• 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 
getU32(uint32_t * offset_ptr) const71 uint32_t DataExtractor::getU32(uint32_t *offset_ptr) const {
72   return getU<uint32_t>(offset_ptr, this, IsLittleEndian, Data.data());
73 }
74 
getU32(uint32_t * offset_ptr,uint32_t * dst,uint32_t count) const75 uint32_t *DataExtractor::getU32(uint32_t *offset_ptr, uint32_t *dst,
76                                 uint32_t count) const {
77   return getUs<uint32_t>(offset_ptr, dst, count, this, IsLittleEndian,
78                         Data.data());
79 }
80 
getU64(uint32_t * offset_ptr) const81 uint64_t DataExtractor::getU64(uint32_t *offset_ptr) const {
82   return getU<uint64_t>(offset_ptr, this, IsLittleEndian, Data.data());
83 }
84 
getU64(uint32_t * offset_ptr,uint64_t * dst,uint32_t count) const85 uint64_t *DataExtractor::getU64(uint32_t *offset_ptr, uint64_t *dst,
86                                 uint32_t count) const {
87   return getUs<uint64_t>(offset_ptr, dst, count, this, IsLittleEndian,
88                         Data.data());
89 }
90 
91 uint64_t
getUnsigned(uint32_t * offset_ptr,uint32_t byte_size) const92 DataExtractor::getUnsigned(uint32_t *offset_ptr, uint32_t byte_size) const {
93   switch (byte_size) {
94   case 1:
95     return getU8(offset_ptr);
96   case 2:
97     return getU16(offset_ptr);
98   case 4:
99     return getU32(offset_ptr);
100   case 8:
101     return getU64(offset_ptr);
102   }
103   llvm_unreachable("getUnsigned unhandled case!");
104 }
105 
106 int64_t
getSigned(uint32_t * offset_ptr,uint32_t byte_size) const107 DataExtractor::getSigned(uint32_t *offset_ptr, uint32_t byte_size) const {
108   switch (byte_size) {
109   case 1:
110     return (int8_t)getU8(offset_ptr);
111   case 2:
112     return (int16_t)getU16(offset_ptr);
113   case 4:
114     return (int32_t)getU32(offset_ptr);
115   case 8:
116     return (int64_t)getU64(offset_ptr);
117   }
118   llvm_unreachable("getSigned unhandled case!");
119 }
120 
getCStr(uint32_t * offset_ptr) const121 const char *DataExtractor::getCStr(uint32_t *offset_ptr) const {
122   uint32_t offset = *offset_ptr;
123   StringRef::size_type pos = Data.find('\0', offset);
124   if (pos != StringRef::npos) {
125     *offset_ptr = pos + 1;
126     return Data.data() + offset;
127   }
128   return nullptr;
129 }
130 
getULEB128(uint32_t * offset_ptr) const131 uint64_t DataExtractor::getULEB128(uint32_t *offset_ptr) const {
132   uint64_t result = 0;
133   if (Data.empty())
134     return 0;
135 
136   unsigned shift = 0;
137   uint32_t offset = *offset_ptr;
138   uint8_t byte = 0;
139 
140   while (isValidOffset(offset)) {
141     byte = Data[offset++];
142     result |= uint64_t(byte & 0x7f) << shift;
143     shift += 7;
144     if ((byte & 0x80) == 0)
145       break;
146   }
147 
148   *offset_ptr = offset;
149   return result;
150 }
151 
getSLEB128(uint32_t * offset_ptr) const152 int64_t DataExtractor::getSLEB128(uint32_t *offset_ptr) const {
153   int64_t result = 0;
154   if (Data.empty())
155     return 0;
156 
157   unsigned shift = 0;
158   uint32_t offset = *offset_ptr;
159   uint8_t byte = 0;
160 
161   while (isValidOffset(offset)) {
162     byte = Data[offset++];
163     result |= uint64_t(byte & 0x7f) << shift;
164     shift += 7;
165     if ((byte & 0x80) == 0)
166       break;
167   }
168 
169   // Sign bit of byte is 2nd high order bit (0x40)
170   if (shift < 64 && (byte & 0x40))
171     result |= -(1ULL << shift);
172 
173   *offset_ptr = offset;
174   return result;
175 }
176