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