1 //===- llvm/unittest/Support/DataExtractorTest.cpp - DataExtractor tests --===//
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
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/Testing/Support/Error.h"
13 #include "gtest/gtest.h"
14 using namespace llvm;
15
16 namespace {
17
18 const char numberData[] = "\x80\x90\xFF\xFF\x80\x00\x00\x00";
19 const char leb128data[] = "\xA6\x49";
20 const char bigleb128data[] = "\xAA\xA9\xFF\xAA\xFF\xAA\xFF\x4A";
21
TEST(DataExtractorTest,OffsetOverflow)22 TEST(DataExtractorTest, OffsetOverflow) {
23 DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
24 EXPECT_FALSE(DE.isValidOffsetForDataOfSize(-2U, 5));
25 }
26
TEST(DataExtractorTest,UnsignedNumbers)27 TEST(DataExtractorTest, UnsignedNumbers) {
28 DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
29 uint64_t offset = 0;
30
31 EXPECT_EQ(0x80U, DE.getU8(&offset));
32 EXPECT_EQ(1U, offset);
33 offset = 0;
34 EXPECT_EQ(0x8090U, DE.getU16(&offset));
35 EXPECT_EQ(2U, offset);
36 offset = 0;
37 EXPECT_EQ(0x8090FFFFU, DE.getU32(&offset));
38 EXPECT_EQ(4U, offset);
39 offset = 0;
40 EXPECT_EQ(0x8090FFFF80000000ULL, DE.getU64(&offset));
41 EXPECT_EQ(8U, offset);
42 offset = 0;
43 EXPECT_EQ(0x8090FFFF80000000ULL, DE.getAddress(&offset));
44 EXPECT_EQ(8U, offset);
45 offset = 0;
46
47 uint32_t data[2];
48 EXPECT_EQ(data, DE.getU32(&offset, data, 2));
49 EXPECT_EQ(0x8090FFFFU, data[0]);
50 EXPECT_EQ(0x80000000U, data[1]);
51 EXPECT_EQ(8U, offset);
52 offset = 0;
53
54 // Now for little endian.
55 DE = DataExtractor(StringRef(numberData, sizeof(numberData)-1), true, 4);
56 EXPECT_EQ(0x9080U, DE.getU16(&offset));
57 EXPECT_EQ(2U, offset);
58 offset = 0;
59 EXPECT_EQ(0xFFFF9080U, DE.getU32(&offset));
60 EXPECT_EQ(4U, offset);
61 offset = 0;
62 EXPECT_EQ(0x80FFFF9080ULL, DE.getU64(&offset));
63 EXPECT_EQ(8U, offset);
64 offset = 0;
65 EXPECT_EQ(0xFFFF9080U, DE.getAddress(&offset));
66 EXPECT_EQ(4U, offset);
67 offset = 0;
68
69 EXPECT_EQ(data, DE.getU32(&offset, data, 2));
70 EXPECT_EQ(0xFFFF9080U, data[0]);
71 EXPECT_EQ(0x80U, data[1]);
72 EXPECT_EQ(8U, offset);
73 }
74
TEST(DataExtractorTest,SignedNumbers)75 TEST(DataExtractorTest, SignedNumbers) {
76 DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
77 uint64_t offset = 0;
78
79 EXPECT_EQ(-128, DE.getSigned(&offset, 1));
80 EXPECT_EQ(1U, offset);
81 offset = 0;
82 EXPECT_EQ(-32624, DE.getSigned(&offset, 2));
83 EXPECT_EQ(2U, offset);
84 offset = 0;
85 EXPECT_EQ(-2137980929, DE.getSigned(&offset, 4));
86 EXPECT_EQ(4U, offset);
87 offset = 0;
88 EXPECT_EQ(-9182558167379214336LL, DE.getSigned(&offset, 8));
89 EXPECT_EQ(8U, offset);
90 }
91
TEST(DataExtractorTest,Strings)92 TEST(DataExtractorTest, Strings) {
93 const char stringData[] = "hellohello\0hello";
94 DataExtractor DE(StringRef(stringData, sizeof(stringData)-1), false, 8);
95 uint64_t offset = 0;
96
97 EXPECT_EQ(stringData, DE.getCStr(&offset));
98 EXPECT_EQ(11U, offset);
99 EXPECT_EQ(nullptr, DE.getCStr(&offset));
100 EXPECT_EQ(11U, offset);
101
102 DataExtractor::Cursor C(0);
103 EXPECT_EQ(stringData, DE.getCStr(C));
104 EXPECT_EQ(11U, C.tell());
105 EXPECT_EQ(nullptr, DE.getCStr(C));
106 EXPECT_EQ(11U, C.tell());
107 EXPECT_THAT_ERROR(
108 C.takeError(),
109 FailedWithMessage("no null terminated string at offset 0xb"));
110 }
111
TEST(DataExtractorTest,LEB128)112 TEST(DataExtractorTest, LEB128) {
113 DataExtractor DE(StringRef(leb128data, sizeof(leb128data)-1), false, 8);
114 uint64_t offset = 0;
115
116 EXPECT_EQ(9382ULL, DE.getULEB128(&offset));
117 EXPECT_EQ(2U, offset);
118 offset = 0;
119 EXPECT_EQ(-7002LL, DE.getSLEB128(&offset));
120 EXPECT_EQ(2U, offset);
121
122 DataExtractor BDE(StringRef(bigleb128data, sizeof(bigleb128data)-1), false,8);
123 offset = 0;
124 EXPECT_EQ(42218325750568106ULL, BDE.getULEB128(&offset));
125 EXPECT_EQ(8U, offset);
126 offset = 0;
127 EXPECT_EQ(-29839268287359830LL, BDE.getSLEB128(&offset));
128 EXPECT_EQ(8U, offset);
129 }
130
TEST(DataExtractorTest,LEB128_error)131 TEST(DataExtractorTest, LEB128_error) {
132 DataExtractor DE(StringRef("\x81"), false, 8);
133 uint64_t Offset = 0;
134 EXPECT_EQ(0U, DE.getULEB128(&Offset));
135 EXPECT_EQ(0U, Offset);
136
137 Offset = 0;
138 EXPECT_EQ(0U, DE.getSLEB128(&Offset));
139 EXPECT_EQ(0U, Offset);
140
141 DataExtractor::Cursor C(0);
142 EXPECT_EQ(0U, DE.getULEB128(C));
143 EXPECT_THAT_ERROR(
144 C.takeError(),
145 FailedWithMessage("unable to decode LEB128 at offset 0x00000000: "
146 "malformed uleb128, extends past end"));
147
148 C = DataExtractor::Cursor(0);
149 EXPECT_EQ(0U, DE.getSLEB128(C));
150 EXPECT_THAT_ERROR(
151 C.takeError(),
152 FailedWithMessage("unable to decode LEB128 at offset 0x00000000: "
153 "malformed sleb128, extends past end"));
154
155 // Show non-zero offsets are reported appropriately.
156 C = DataExtractor::Cursor(1);
157 EXPECT_EQ(0U, DE.getULEB128(C));
158 EXPECT_THAT_ERROR(
159 C.takeError(),
160 FailedWithMessage("unable to decode LEB128 at offset 0x00000001: "
161 "malformed uleb128, extends past end"));
162 }
163
TEST(DataExtractorTest,Cursor_tell)164 TEST(DataExtractorTest, Cursor_tell) {
165 DataExtractor DE(StringRef("AB"), false, 8);
166 DataExtractor::Cursor C(0);
167 // A successful read operation advances the cursor
168 EXPECT_EQ('A', DE.getU8(C));
169 EXPECT_EQ(1u, C.tell());
170
171 // An unsuccessful one doesn't.
172 EXPECT_EQ(0u, DE.getU16(C));
173 EXPECT_EQ(1u, C.tell());
174
175 // And neither do any subsequent operations.
176 EXPECT_EQ(0, DE.getU8(C));
177 EXPECT_EQ(1u, C.tell());
178
179 consumeError(C.takeError());
180 }
181
TEST(DataExtractorTest,Cursor_seek)182 TEST(DataExtractorTest, Cursor_seek) {
183 DataExtractor::Cursor C(5);
184
185 C.seek(3);
186 EXPECT_EQ(3u, C.tell());
187
188 C.seek(8);
189 EXPECT_EQ(8u, C.tell());
190
191 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
192 }
193
TEST(DataExtractorTest,Cursor_takeError)194 TEST(DataExtractorTest, Cursor_takeError) {
195 DataExtractor DE(StringRef("AB"), false, 8);
196 DataExtractor::Cursor C(0);
197 // Initially, the cursor is in the "success" state.
198 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
199
200 // It remains "success" after a successful read.
201 EXPECT_EQ('A', DE.getU8(C));
202 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
203
204 // An unsuccessful read sets the error state.
205 EXPECT_EQ(0u, DE.getU32(C));
206 EXPECT_THAT_ERROR(C.takeError(), Failed());
207
208 // Once set the error sticks until explicitly cleared.
209 EXPECT_EQ(0u, DE.getU32(C));
210 EXPECT_EQ(0, DE.getU8(C));
211 EXPECT_THAT_ERROR(C.takeError(), Failed());
212
213 // At which point reads can be succeed again.
214 EXPECT_EQ('B', DE.getU8(C));
215 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
216 }
217
TEST(DataExtractorTest,Cursor_chaining)218 TEST(DataExtractorTest, Cursor_chaining) {
219 DataExtractor DE(StringRef("ABCD"), false, 8);
220 DataExtractor::Cursor C(0);
221
222 // Multiple reads can be chained without trigerring any assertions.
223 EXPECT_EQ('A', DE.getU8(C));
224 EXPECT_EQ('B', DE.getU8(C));
225 EXPECT_EQ('C', DE.getU8(C));
226 EXPECT_EQ('D', DE.getU8(C));
227 // And the error checked at the end.
228 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
229 }
230
231 #if defined(GTEST_HAS_DEATH_TEST) && defined(_DEBUG) && \
232 LLVM_ENABLE_ABI_BREAKING_CHECKS
TEST(DataExtractorDeathTest,Cursor)233 TEST(DataExtractorDeathTest, Cursor) {
234 DataExtractor DE(StringRef("AB"), false, 8);
235
236 // Even an unused cursor must be checked for errors:
237 EXPECT_DEATH(DataExtractor::Cursor(0),
238 "Success values must still be checked prior to being destroyed");
239
240 {
241 auto C = std::make_unique<DataExtractor::Cursor>(0);
242 EXPECT_EQ(0u, DE.getU32(*C));
243 // It must also be checked after an unsuccessful operation.
244 // destruction.
245 EXPECT_DEATH(C.reset(), "unexpected end of data");
246 EXPECT_THAT_ERROR(C->takeError(), Failed());
247 }
248 {
249 auto C = std::make_unique<DataExtractor::Cursor>(0);
250 EXPECT_EQ('A', DE.getU8(*C));
251 // Same goes for a successful one.
252 EXPECT_DEATH(
253 C.reset(),
254 "Success values must still be checked prior to being destroyed");
255 EXPECT_THAT_ERROR(C->takeError(), Succeeded());
256 }
257 {
258 auto C = std::make_unique<DataExtractor::Cursor>(0);
259 EXPECT_EQ('A', DE.getU8(*C));
260 EXPECT_EQ(0u, DE.getU32(*C));
261 // Even if a successful operation is followed by an unsuccessful one.
262 EXPECT_DEATH(C.reset(), "unexpected end of data");
263 EXPECT_THAT_ERROR(C->takeError(), Failed());
264 }
265 {
266 auto C = std::make_unique<DataExtractor::Cursor>(0);
267 EXPECT_EQ(0u, DE.getU32(*C));
268 EXPECT_EQ(0, DE.getU8(*C));
269 // Even if an unsuccessful operation is followed by one that would normally
270 // succeed.
271 EXPECT_DEATH(C.reset(), "unexpected end of data");
272 EXPECT_THAT_ERROR(C->takeError(), Failed());
273 }
274 }
275 #endif
276
TEST(DataExtractorTest,getU8_vector)277 TEST(DataExtractorTest, getU8_vector) {
278 DataExtractor DE(StringRef("AB"), false, 8);
279 DataExtractor::Cursor C(0);
280 SmallVector<uint8_t, 2> S;
281
282 DE.getU8(C, S, 4);
283 EXPECT_THAT_ERROR(C.takeError(), Failed());
284 EXPECT_EQ("", toStringRef(S));
285
286 DE.getU8(C, S, 2);
287 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
288 EXPECT_EQ("AB", toStringRef(S));
289
290 C = DataExtractor::Cursor(0x47);
291 DE.getU8(C, S, 2);
292 EXPECT_THAT_ERROR(
293 C.takeError(),
294 FailedWithMessage("offset 0x47 is beyond the end of data at 0x2"));
295 }
296
TEST(DataExtractorTest,getU24)297 TEST(DataExtractorTest, getU24) {
298 DataExtractor DE(StringRef("ABCD"), false, 8);
299 DataExtractor::Cursor C(0);
300
301 EXPECT_EQ(0x414243u, DE.getU24(C));
302 EXPECT_EQ(0u, DE.getU24(C));
303 EXPECT_EQ(3u, C.tell());
304 EXPECT_THAT_ERROR(C.takeError(), Failed());
305 }
306
TEST(DataExtractorTest,skip)307 TEST(DataExtractorTest, skip) {
308 DataExtractor DE(StringRef("AB"), false, 8);
309 DataExtractor::Cursor C(0);
310
311 DE.skip(C, 4);
312 EXPECT_THAT_ERROR(C.takeError(), Failed());
313 EXPECT_EQ(0u, C.tell());
314
315 DE.skip(C, 2);
316 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
317 EXPECT_EQ(2u, C.tell());
318 }
319
TEST(DataExtractorTest,eof)320 TEST(DataExtractorTest, eof) {
321 DataExtractor DE(StringRef("A"), false, 8);
322 DataExtractor::Cursor C(0);
323
324 EXPECT_FALSE(DE.eof(C));
325
326 EXPECT_EQ(0, DE.getU16(C));
327 EXPECT_FALSE(DE.eof(C));
328 EXPECT_THAT_ERROR(C.takeError(), Failed());
329
330 EXPECT_EQ('A', DE.getU8(C));
331 EXPECT_TRUE(DE.eof(C));
332 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
333 }
334
TEST(DataExtractorTest,size)335 TEST(DataExtractorTest, size) {
336 uint8_t Data[] = {'A', 'B', 'C', 'D'};
337 DataExtractor DE1(StringRef(reinterpret_cast<char *>(Data), sizeof(Data)),
338 false, 8);
339 EXPECT_EQ(DE1.size(), sizeof(Data));
340 DataExtractor DE2(ArrayRef<uint8_t>(Data), false, 8);
341 EXPECT_EQ(DE2.size(), sizeof(Data));
342 }
343
TEST(DataExtractorTest,FixedLengthString)344 TEST(DataExtractorTest, FixedLengthString) {
345 const char Data[] = "hello\x00\x00\x00world \thola\x00";
346 DataExtractor DE(StringRef(Data, sizeof(Data)-1), false, 8);
347 uint64_t Offset = 0;
348 StringRef Str;
349 // Test extracting too many bytes doesn't modify Offset and returns
350 // std::nullopt.
351 Str = DE.getFixedLengthString(&Offset, sizeof(Data));
352 EXPECT_TRUE(Str.empty());
353 EXPECT_EQ(Offset, 0u);
354
355 // Test extracting a fixed width C string with trailing NULL characters.
356 Str = DE.getFixedLengthString(&Offset, 8);
357 EXPECT_EQ(Offset, 8u);
358 EXPECT_EQ(Str.size(), 5u);
359 EXPECT_EQ(Str, "hello");
360 // Test extracting a fixed width C string with trailing space and tab
361 // characters.
362 Str = DE.getFixedLengthString(&Offset, 8, " \t");
363 EXPECT_EQ(Offset, 16u);
364 EXPECT_EQ(Str.size(), 5u);
365 EXPECT_EQ(Str, "world");
366 // Now extract a normal C string.
367 Str = DE.getCStrRef(&Offset);
368 EXPECT_EQ(Str.size(), 4u);
369 EXPECT_EQ(Str, "hola");
370 }
371
372
TEST(DataExtractorTest,GetBytes)373 TEST(DataExtractorTest, GetBytes) {
374 // Use data with an embedded NULL character for good measure.
375 const char Data[] = "\x01\x02\x00\x04";
376 StringRef Bytes(Data, sizeof(Data)-1);
377 DataExtractor DE(Bytes, false, 8);
378 uint64_t Offset = 0;
379 StringRef Str;
380 // Test extracting too many bytes doesn't modify Offset and returns
381 // std::nullopt.
382 Str = DE.getBytes(&Offset, sizeof(Data));
383 EXPECT_TRUE(Str.empty());
384 EXPECT_EQ(Offset, 0u);
385 // Test extracting 4 bytes from the stream.
386 Str = DE.getBytes(&Offset, 4);
387 EXPECT_EQ(Offset, 4u);
388 EXPECT_EQ(Str.size(), 4u);
389 EXPECT_EQ(Str, Bytes);
390
391 DataExtractor::Cursor C(0);
392 EXPECT_EQ(StringRef("\x01\x02"), DE.getBytes(C, 2));
393 EXPECT_EQ(StringRef("\x00\x04", 2), DE.getBytes(C, 2));
394 EXPECT_EQ(StringRef(), DE.getBytes(C, 2));
395 EXPECT_EQ(StringRef(), DE.getBytes(C, 2));
396 EXPECT_EQ(4u, C.tell());
397 EXPECT_THAT_ERROR(C.takeError(), Failed());
398 }
399
400 }
401