1 //===-- DataExtractor.cpp -------------------------------------------------===//
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 #include "llvm/Support/DataExtractor.h"
10 #include "llvm/Support/Errc.h"
11 #include "llvm/Support/ErrorHandling.h"
12 #include "llvm/Support/Host.h"
13 #include "llvm/Support/LEB128.h"
14 #include "llvm/Support/SwapByteOrder.h"
15 
16 using namespace llvm;
17 
18 static void unexpectedEndReached(Error *E) {
19   if (E)
20     *E = createStringError(errc::illegal_byte_sequence,
21                            "unexpected end of data");
22 }
23 
24 static bool isError(Error *E) { return E && *E; }
25 
26 template <typename T>
27 static T getU(uint64_t *offset_ptr, const DataExtractor *de,
28               bool isLittleEndian, const char *Data, llvm::Error *Err) {
29   ErrorAsOutParameter ErrAsOut(Err);
30   T val = 0;
31   if (isError(Err))
32     return val;
33 
34   uint64_t offset = *offset_ptr;
35   if (!de->isValidOffsetForDataOfSize(offset, sizeof(T))) {
36     unexpectedEndReached(Err);
37     return val;
38   }
39   std::memcpy(&val, &Data[offset], sizeof(val));
40   if (sys::IsLittleEndianHost != isLittleEndian)
41     sys::swapByteOrder(val);
42 
43   // Advance the offset
44   *offset_ptr += sizeof(val);
45   return val;
46 }
47 
48 template <typename T>
49 static T *getUs(uint64_t *offset_ptr, T *dst, uint32_t count,
50                 const DataExtractor *de, bool isLittleEndian, const char *Data,
51                 llvm::Error *Err) {
52   ErrorAsOutParameter ErrAsOut(Err);
53   if (isError(Err))
54     return nullptr;
55 
56   uint64_t offset = *offset_ptr;
57 
58   if (!de->isValidOffsetForDataOfSize(offset, sizeof(*dst) * count)) {
59     unexpectedEndReached(Err);
60     return nullptr;
61   }
62   for (T *value_ptr = dst, *end = dst + count; value_ptr != end;
63        ++value_ptr, offset += sizeof(*dst))
64     *value_ptr = getU<T>(offset_ptr, de, isLittleEndian, Data, Err);
65   // Advance the offset
66   *offset_ptr = offset;
67   // Return a non-NULL pointer to the converted data as an indicator of
68   // success
69   return dst;
70 }
71 
72 uint8_t DataExtractor::getU8(uint64_t *offset_ptr, llvm::Error *Err) const {
73   return getU<uint8_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
74 }
75 
76 uint8_t *
77 DataExtractor::getU8(uint64_t *offset_ptr, uint8_t *dst, uint32_t count) const {
78   return getUs<uint8_t>(offset_ptr, dst, count, this, IsLittleEndian,
79                         Data.data(), nullptr);
80 }
81 
82 uint8_t *DataExtractor::getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const {
83   return getUs<uint8_t>(&C.Offset, Dst, Count, this, IsLittleEndian,
84                         Data.data(), &C.Err);
85 }
86 
87 uint16_t DataExtractor::getU16(uint64_t *offset_ptr, llvm::Error *Err) const {
88   return getU<uint16_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
89 }
90 
91 uint16_t *DataExtractor::getU16(uint64_t *offset_ptr, uint16_t *dst,
92                                 uint32_t count) const {
93   return getUs<uint16_t>(offset_ptr, dst, count, this, IsLittleEndian,
94                          Data.data(), nullptr);
95 }
96 
97 uint32_t DataExtractor::getU24(uint64_t *offset_ptr) const {
98   uint24_t ExtractedVal =
99       getU<uint24_t>(offset_ptr, this, IsLittleEndian, Data.data(), nullptr);
100   // The 3 bytes are in the correct byte order for the host.
101   return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
102 }
103 
104 uint32_t DataExtractor::getU32(uint64_t *offset_ptr, llvm::Error *Err) const {
105   return getU<uint32_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
106 }
107 
108 uint32_t *DataExtractor::getU32(uint64_t *offset_ptr, uint32_t *dst,
109                                 uint32_t count) const {
110   return getUs<uint32_t>(offset_ptr, dst, count, this, IsLittleEndian,
111                          Data.data(), nullptr);
112 }
113 
114 uint64_t DataExtractor::getU64(uint64_t *offset_ptr, llvm::Error *Err) const {
115   return getU<uint64_t>(offset_ptr, this, IsLittleEndian, Data.data(), Err);
116 }
117 
118 uint64_t *DataExtractor::getU64(uint64_t *offset_ptr, uint64_t *dst,
119                                 uint32_t count) const {
120   return getUs<uint64_t>(offset_ptr, dst, count, this, IsLittleEndian,
121                          Data.data(), nullptr);
122 }
123 
124 uint64_t DataExtractor::getUnsigned(uint64_t *offset_ptr, uint32_t byte_size,
125                                     llvm::Error *Err) const {
126   switch (byte_size) {
127   case 1:
128     return getU8(offset_ptr, Err);
129   case 2:
130     return getU16(offset_ptr, Err);
131   case 4:
132     return getU32(offset_ptr, Err);
133   case 8:
134     return getU64(offset_ptr, Err);
135   }
136   llvm_unreachable("getUnsigned unhandled case!");
137 }
138 
139 int64_t
140 DataExtractor::getSigned(uint64_t *offset_ptr, uint32_t byte_size) const {
141   switch (byte_size) {
142   case 1:
143     return (int8_t)getU8(offset_ptr);
144   case 2:
145     return (int16_t)getU16(offset_ptr);
146   case 4:
147     return (int32_t)getU32(offset_ptr);
148   case 8:
149     return (int64_t)getU64(offset_ptr);
150   }
151   llvm_unreachable("getSigned unhandled case!");
152 }
153 
154 const char *DataExtractor::getCStr(uint64_t *offset_ptr) const {
155   uint64_t offset = *offset_ptr;
156   StringRef::size_type pos = Data.find('\0', offset);
157   if (pos != StringRef::npos) {
158     *offset_ptr = pos + 1;
159     return Data.data() + offset;
160   }
161   return nullptr;
162 }
163 
164 StringRef DataExtractor::getCStrRef(uint64_t *offset_ptr) const {
165   uint64_t Start = *offset_ptr;
166   StringRef::size_type Pos = Data.find('\0', Start);
167   if (Pos != StringRef::npos) {
168     *offset_ptr = Pos + 1;
169     return StringRef(Data.data() + Start, Pos - Start);
170   }
171   return StringRef();
172 }
173 
174 uint64_t DataExtractor::getULEB128(uint64_t *offset_ptr,
175                                    llvm::Error *Err) const {
176   assert(*offset_ptr <= Data.size());
177   ErrorAsOutParameter ErrAsOut(Err);
178   if (isError(Err))
179     return 0;
180 
181   const char *error;
182   unsigned bytes_read;
183   uint64_t result = decodeULEB128(
184       reinterpret_cast<const uint8_t *>(Data.data() + *offset_ptr), &bytes_read,
185       reinterpret_cast<const uint8_t *>(Data.data() + Data.size()), &error);
186   if (error) {
187     if (Err)
188       *Err = createStringError(errc::illegal_byte_sequence, error);
189     return 0;
190   }
191   *offset_ptr += bytes_read;
192   return result;
193 }
194 
195 int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr) const {
196   assert(*offset_ptr <= Data.size());
197 
198   const char *error;
199   unsigned bytes_read;
200   int64_t result = decodeSLEB128(
201       reinterpret_cast<const uint8_t *>(Data.data() + *offset_ptr), &bytes_read,
202       reinterpret_cast<const uint8_t *>(Data.data() + Data.size()), &error);
203   if (error)
204     return 0;
205   *offset_ptr += bytes_read;
206   return result;
207 }
208 
209 void DataExtractor::skip(Cursor &C, uint64_t Length) const {
210   ErrorAsOutParameter ErrAsOut(&C.Err);
211   if (isError(&C.Err))
212     return;
213 
214   if (isValidOffsetForDataOfSize(C.Offset, Length))
215     C.Offset += Length;
216   else
217     unexpectedEndReached(&C.Err);
218 }
219