OLD | NEW |
1 // Copyright (c) 2010, Google Inc. | 1 // Copyright (c) 2010, Google Inc. |
2 // All rights reserved. | 2 // All rights reserved. |
3 // | 3 // |
4 // Redistribution and use in source and binary forms, with or without | 4 // Redistribution and use in source and binary forms, with or without |
5 // modification, are permitted provided that the following conditions are | 5 // modification, are permitted provided that the following conditions are |
6 // met: | 6 // met: |
7 // | 7 // |
8 // * Redistributions of source code must retain the above copyright | 8 // * Redistributions of source code must retain the above copyright |
9 // notice, this list of conditions and the following disclaimer. | 9 // notice, this list of conditions and the following disclaimer. |
10 // * Redistributions in binary form must reproduce the above | 10 // * Redistributions in binary form must reproduce the above |
(...skipping 13 matching lines...) Expand all Loading... |
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
29 | 29 |
30 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com> | 30 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com> |
31 | 31 |
32 // bytereader_unittest.cc: Unit tests for dwarf2reader::ByteReader | 32 // bytereader_unittest.cc: Unit tests for dwarf2reader::ByteReader |
33 | 33 |
| 34 #include <stdint.h> |
| 35 |
34 #include <string> | 36 #include <string> |
35 | 37 |
36 #include "breakpad_googletest_includes.h" | 38 #include "breakpad_googletest_includes.h" |
37 #include "common/dwarf/bytereader.h" | 39 #include "common/dwarf/bytereader.h" |
38 #include "common/dwarf/bytereader-inl.h" | 40 #include "common/dwarf/bytereader-inl.h" |
39 #include "common/dwarf/cfi_assembler.h" | 41 #include "common/dwarf/cfi_assembler.h" |
40 #include "common/using_std_string.h" | 42 #include "common/using_std_string.h" |
41 | 43 |
42 using dwarf2reader::ByteReader; | 44 using dwarf2reader::ByteReader; |
43 using dwarf2reader::DwarfPointerEncoding; | 45 using dwarf2reader::DwarfPointerEncoding; |
(...skipping 20 matching lines...) Expand all Loading... |
64 CFISection section(kBigEndian, 4); | 66 CFISection section(kBigEndian, 4); |
65 section | 67 section |
66 .D8(0xc0) | 68 .D8(0xc0) |
67 .D16(0xcf0d) | 69 .D16(0xcf0d) |
68 .D32(0x96fdd219) | 70 .D32(0x96fdd219) |
69 .D64(0xbbf55fef0825f117ULL) | 71 .D64(0xbbf55fef0825f117ULL) |
70 .ULEB128(0xa0927048ba8121afULL) | 72 .ULEB128(0xa0927048ba8121afULL) |
71 .LEB128(-0x4f337badf4483f83LL) | 73 .LEB128(-0x4f337badf4483f83LL) |
72 .D32(0xfec319c9); | 74 .D32(0xfec319c9); |
73 ASSERT_TRUE(section.GetContents(&contents)); | 75 ASSERT_TRUE(section.GetContents(&contents)); |
74 const char *data = contents.data(); | 76 const uint8_t *data = reinterpret_cast<const uint8_t *>(contents.data()); |
75 EXPECT_EQ(0xc0U, reader.ReadOneByte(data)); | 77 EXPECT_EQ(0xc0U, reader.ReadOneByte(data)); |
76 EXPECT_EQ(0xcf0dU, reader.ReadTwoBytes(data + 1)); | 78 EXPECT_EQ(0xcf0dU, reader.ReadTwoBytes(data + 1)); |
77 EXPECT_EQ(0x96fdd219U, reader.ReadFourBytes(data + 3)); | 79 EXPECT_EQ(0x96fdd219U, reader.ReadFourBytes(data + 3)); |
78 EXPECT_EQ(0xbbf55fef0825f117ULL, reader.ReadEightBytes(data + 7)); | 80 EXPECT_EQ(0xbbf55fef0825f117ULL, reader.ReadEightBytes(data + 7)); |
79 size_t leb128_size; | 81 size_t leb128_size; |
80 EXPECT_EQ(0xa0927048ba8121afULL, | 82 EXPECT_EQ(0xa0927048ba8121afULL, |
81 reader.ReadUnsignedLEB128(data + 15, &leb128_size)); | 83 reader.ReadUnsignedLEB128(data + 15, &leb128_size)); |
82 EXPECT_EQ(10U, leb128_size); | 84 EXPECT_EQ(10U, leb128_size); |
83 EXPECT_EQ(-0x4f337badf4483f83LL, | 85 EXPECT_EQ(-0x4f337badf4483f83LL, |
84 reader.ReadSignedLEB128(data + 25, &leb128_size)); | 86 reader.ReadSignedLEB128(data + 25, &leb128_size)); |
(...skipping 283 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
368 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0d))); | 370 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0d))); |
369 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0f))); | 371 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0f))); |
370 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x51))); | 372 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x51))); |
371 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x60))); | 373 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x60))); |
372 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x70))); | 374 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x70))); |
373 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xf0))); | 375 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xf0))); |
374 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xd0))); | 376 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xd0))); |
375 } | 377 } |
376 | 378 |
377 TEST_F(ReaderDeathTest, DW_EH_PE_omit) { | 379 TEST_F(ReaderDeathTest, DW_EH_PE_omit) { |
378 static const char data[1] = { 42 }; | 380 static const uint8_t data[] = { 42 }; |
379 ByteReader reader(ENDIANNESS_BIG); | 381 ByteReader reader(ENDIANNESS_BIG); |
380 reader.SetAddressSize(4); | 382 reader.SetAddressSize(4); |
381 EXPECT_DEATH(reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_omit, | 383 EXPECT_DEATH(reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_omit, |
382 &pointer_size), | 384 &pointer_size), |
383 "encoding != DW_EH_PE_omit"); | 385 "encoding != DW_EH_PE_omit"); |
384 } | 386 } |
385 | 387 |
386 TEST_F(Reader, DW_EH_PE_absptr4) { | 388 TEST_F(Reader, DW_EH_PE_absptr4) { |
387 static const char data[] = { 0x27, 0x57, 0xea, 0x40 }; | 389 static const uint8_t data[] = { 0x27, 0x57, 0xea, 0x40 }; |
388 ByteReader reader(ENDIANNESS_LITTLE); | 390 ByteReader reader(ENDIANNESS_LITTLE); |
389 reader.SetAddressSize(4); | 391 reader.SetAddressSize(4); |
390 EXPECT_EQ(0x40ea5727U, | 392 EXPECT_EQ(0x40ea5727U, |
391 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_absptr, | 393 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_absptr, |
392 &pointer_size)); | 394 &pointer_size)); |
393 EXPECT_EQ(4U, pointer_size); | 395 EXPECT_EQ(4U, pointer_size); |
394 } | 396 } |
395 | 397 |
396 TEST_F(Reader, DW_EH_PE_absptr8) { | 398 TEST_F(Reader, DW_EH_PE_absptr8) { |
397 static const char data[] = { | 399 static const uint8_t data[] = { |
398 0x60, 0x27, 0x57, 0xea, 0x40, 0xc2, 0x98, 0x05, 0x01, 0x50 | 400 0x60, 0x27, 0x57, 0xea, 0x40, 0xc2, 0x98, 0x05, 0x01, 0x50 |
399 }; | 401 }; |
400 ByteReader reader(ENDIANNESS_LITTLE); | 402 ByteReader reader(ENDIANNESS_LITTLE); |
401 reader.SetAddressSize(8); | 403 reader.SetAddressSize(8); |
402 EXPECT_EQ(0x010598c240ea5727ULL, | 404 EXPECT_EQ(0x010598c240ea5727ULL, |
403 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_absptr, | 405 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_absptr, |
404 &pointer_size)); | 406 &pointer_size)); |
405 EXPECT_EQ(8U, pointer_size); | 407 EXPECT_EQ(8U, pointer_size); |
406 } | 408 } |
407 | 409 |
408 TEST_F(Reader, DW_EH_PE_uleb128) { | 410 TEST_F(Reader, DW_EH_PE_uleb128) { |
409 static const char data[] = { 0x81, 0x84, 0x4c }; | 411 static const uint8_t data[] = { 0x81, 0x84, 0x4c }; |
410 ByteReader reader(ENDIANNESS_LITTLE); | 412 ByteReader reader(ENDIANNESS_LITTLE); |
411 reader.SetAddressSize(4); | 413 reader.SetAddressSize(4); |
412 EXPECT_EQ(0x130201U, | 414 EXPECT_EQ(0x130201U, |
413 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_uleb128, | 415 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_uleb128, |
414 &pointer_size)); | 416 &pointer_size)); |
415 EXPECT_EQ(3U, pointer_size); | 417 EXPECT_EQ(3U, pointer_size); |
416 } | 418 } |
417 | 419 |
418 TEST_F(Reader, DW_EH_PE_udata2) { | 420 TEST_F(Reader, DW_EH_PE_udata2) { |
419 static const char data[] = { 0xf4, 0x8d }; | 421 static const uint8_t data[] = { 0xf4, 0x8d }; |
420 ByteReader reader(ENDIANNESS_BIG); | 422 ByteReader reader(ENDIANNESS_BIG); |
421 reader.SetAddressSize(4); | 423 reader.SetAddressSize(4); |
422 EXPECT_EQ(0xf48dU, | 424 EXPECT_EQ(0xf48dU, |
423 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_udata2, | 425 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_udata2, |
424 &pointer_size)); | 426 &pointer_size)); |
425 EXPECT_EQ(2U, pointer_size); | 427 EXPECT_EQ(2U, pointer_size); |
426 } | 428 } |
427 | 429 |
428 TEST_F(Reader, DW_EH_PE_udata4) { | 430 TEST_F(Reader, DW_EH_PE_udata4) { |
429 static const char data[] = { 0xb2, 0x68, 0xa5, 0x62, 0x8f, 0x8b }; | 431 static const uint8_t data[] = { 0xb2, 0x68, 0xa5, 0x62, 0x8f, 0x8b }; |
430 ByteReader reader(ENDIANNESS_BIG); | 432 ByteReader reader(ENDIANNESS_BIG); |
431 reader.SetAddressSize(8); | 433 reader.SetAddressSize(8); |
432 EXPECT_EQ(0xa5628f8b, | 434 EXPECT_EQ(0xa5628f8b, |
433 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_udata4, | 435 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_udata4, |
434 &pointer_size)); | 436 &pointer_size)); |
435 EXPECT_EQ(4U, pointer_size); | 437 EXPECT_EQ(4U, pointer_size); |
436 } | 438 } |
437 | 439 |
438 TEST_F(Reader, DW_EH_PE_udata8Addr8) { | 440 TEST_F(Reader, DW_EH_PE_udata8Addr8) { |
439 static const char data[] = { | 441 static const uint8_t data[] = { |
440 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe | 442 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe |
441 }; | 443 }; |
442 ByteReader reader(ENDIANNESS_LITTLE); | 444 ByteReader reader(ENDIANNESS_LITTLE); |
443 reader.SetAddressSize(8); | 445 reader.SetAddressSize(8); |
444 EXPECT_EQ(0x8fed199f69047304ULL, | 446 EXPECT_EQ(0x8fed199f69047304ULL, |
445 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8, | 447 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8, |
446 &pointer_size)); | 448 &pointer_size)); |
447 EXPECT_EQ(8U, pointer_size); | 449 EXPECT_EQ(8U, pointer_size); |
448 } | 450 } |
449 | 451 |
450 TEST_F(Reader, DW_EH_PE_udata8Addr4) { | 452 TEST_F(Reader, DW_EH_PE_udata8Addr4) { |
451 static const char data[] = { | 453 static const uint8_t data[] = { |
452 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe | 454 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe |
453 }; | 455 }; |
454 ByteReader reader(ENDIANNESS_LITTLE); | 456 ByteReader reader(ENDIANNESS_LITTLE); |
455 reader.SetAddressSize(4); | 457 reader.SetAddressSize(4); |
456 EXPECT_EQ(0x69047304ULL, | 458 EXPECT_EQ(0x69047304ULL, |
457 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8, | 459 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8, |
458 &pointer_size)); | 460 &pointer_size)); |
459 EXPECT_EQ(8U, pointer_size); | 461 EXPECT_EQ(8U, pointer_size); |
460 } | 462 } |
461 | 463 |
462 TEST_F(Reader, DW_EH_PE_sleb128) { | 464 TEST_F(Reader, DW_EH_PE_sleb128) { |
463 static const char data[] = { 0x42, 0xff, 0xfb, 0x73 }; | 465 static const uint8_t data[] = { 0x42, 0xff, 0xfb, 0x73 }; |
464 ByteReader reader(ENDIANNESS_BIG); | 466 ByteReader reader(ENDIANNESS_BIG); |
465 reader.SetAddressSize(4); | 467 reader.SetAddressSize(4); |
466 EXPECT_EQ(-0x030201U & 0xffffffff, | 468 EXPECT_EQ(-0x030201U & 0xffffffff, |
467 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sleb128, | 469 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sleb128, |
468 &pointer_size)); | 470 &pointer_size)); |
469 EXPECT_EQ(3U, pointer_size); | 471 EXPECT_EQ(3U, pointer_size); |
470 } | 472 } |
471 | 473 |
472 TEST_F(Reader, DW_EH_PE_sdata2) { | 474 TEST_F(Reader, DW_EH_PE_sdata2) { |
473 static const char data[] = { 0xb9, 0xbf }; | 475 static const uint8_t data[] = { 0xb9, 0xbf }; |
474 ByteReader reader(ENDIANNESS_LITTLE); | 476 ByteReader reader(ENDIANNESS_LITTLE); |
475 reader.SetAddressSize(8); | 477 reader.SetAddressSize(8); |
476 EXPECT_EQ(0xffffffffffffbfb9ULL, | 478 EXPECT_EQ(0xffffffffffffbfb9ULL, |
477 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_sdata2, | 479 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_sdata2, |
478 &pointer_size)); | 480 &pointer_size)); |
479 EXPECT_EQ(2U, pointer_size); | 481 EXPECT_EQ(2U, pointer_size); |
480 } | 482 } |
481 | 483 |
482 TEST_F(Reader, DW_EH_PE_sdata4) { | 484 TEST_F(Reader, DW_EH_PE_sdata4) { |
483 static const char data[] = { 0xa0, 0xca, 0xf2, 0xb8, 0xc2, 0xad }; | 485 static const uint8_t data[] = { 0xa0, 0xca, 0xf2, 0xb8, 0xc2, 0xad }; |
484 ByteReader reader(ENDIANNESS_LITTLE); | 486 ByteReader reader(ENDIANNESS_LITTLE); |
485 reader.SetAddressSize(8); | 487 reader.SetAddressSize(8); |
486 EXPECT_EQ(0xffffffffadc2b8f2ULL, | 488 EXPECT_EQ(0xffffffffadc2b8f2ULL, |
487 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_sdata4, | 489 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_sdata4, |
488 &pointer_size)); | 490 &pointer_size)); |
489 EXPECT_EQ(4U, pointer_size); | 491 EXPECT_EQ(4U, pointer_size); |
490 } | 492 } |
491 | 493 |
492 TEST_F(Reader, DW_EH_PE_sdata8) { | 494 TEST_F(Reader, DW_EH_PE_sdata8) { |
493 static const char data[] = { | 495 static const uint8_t data[] = { |
494 0xf6, 0x66, 0x57, 0x79, 0xe0, 0x0c, 0x9b, 0x26, 0x87 | 496 0xf6, 0x66, 0x57, 0x79, 0xe0, 0x0c, 0x9b, 0x26, 0x87 |
495 }; | 497 }; |
496 ByteReader reader(ENDIANNESS_LITTLE); | 498 ByteReader reader(ENDIANNESS_LITTLE); |
497 reader.SetAddressSize(8); | 499 reader.SetAddressSize(8); |
498 EXPECT_EQ(0x87269b0ce0795766ULL, | 500 EXPECT_EQ(0x87269b0ce0795766ULL, |
499 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sdata8, | 501 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sdata8, |
500 &pointer_size)); | 502 &pointer_size)); |
501 EXPECT_EQ(8U, pointer_size); | 503 EXPECT_EQ(8U, pointer_size); |
502 } | 504 } |
503 | 505 |
504 TEST_F(Reader, DW_EH_PE_pcrel) { | 506 TEST_F(Reader, DW_EH_PE_pcrel) { |
505 static const char data[] = { 0x4a, 0x8b, 0x1b, 0x14, 0xc8, 0xc4, 0x02, 0xce }; | 507 static const uint8_t data[] = { |
| 508 0x4a, 0x8b, 0x1b, 0x14, 0xc8, 0xc4, 0x02, 0xce |
| 509 }; |
506 ByteReader reader(ENDIANNESS_BIG); | 510 ByteReader reader(ENDIANNESS_BIG); |
507 reader.SetAddressSize(4); | 511 reader.SetAddressSize(4); |
508 DwarfPointerEncoding encoding = | 512 DwarfPointerEncoding encoding = |
509 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_pcrel | 513 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_pcrel |
510 | dwarf2reader::DW_EH_PE_absptr); | 514 | dwarf2reader::DW_EH_PE_absptr); |
511 reader.SetCFIDataBase(0x89951377, data); | 515 reader.SetCFIDataBase(0x89951377, data); |
512 EXPECT_EQ(0x89951377 + 3 + 0x14c8c402, | 516 EXPECT_EQ(0x89951377 + 3 + 0x14c8c402, |
513 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size)); | 517 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size)); |
514 EXPECT_EQ(4U, pointer_size); | 518 EXPECT_EQ(4U, pointer_size); |
515 } | 519 } |
516 | 520 |
517 TEST_F(Reader, DW_EH_PE_textrel) { | 521 TEST_F(Reader, DW_EH_PE_textrel) { |
518 static const char data[] = { 0xd9, 0x0d, 0x05, 0x17, 0xc9, 0x7a, 0x42, 0x1e }; | 522 static const uint8_t data[] = { |
| 523 0xd9, 0x0d, 0x05, 0x17, 0xc9, 0x7a, 0x42, 0x1e |
| 524 }; |
519 ByteReader reader(ENDIANNESS_LITTLE); | 525 ByteReader reader(ENDIANNESS_LITTLE); |
520 reader.SetAddressSize(4); | 526 reader.SetAddressSize(4); |
521 reader.SetTextBase(0xb91beaf0); | 527 reader.SetTextBase(0xb91beaf0); |
522 DwarfPointerEncoding encoding = | 528 DwarfPointerEncoding encoding = |
523 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_textrel | 529 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_textrel |
524 | dwarf2reader::DW_EH_PE_sdata2); | 530 | dwarf2reader::DW_EH_PE_sdata2); |
525 EXPECT_EQ((0xb91beaf0 + 0xffffc917) & 0xffffffff, | 531 EXPECT_EQ((0xb91beaf0 + 0xffffc917) & 0xffffffff, |
526 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size)); | 532 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size)); |
527 EXPECT_EQ(2U, pointer_size); | 533 EXPECT_EQ(2U, pointer_size); |
528 } | 534 } |
529 | 535 |
530 TEST_F(Reader, DW_EH_PE_datarel) { | 536 TEST_F(Reader, DW_EH_PE_datarel) { |
531 static const char data[] = { 0x16, 0xf2, 0xbb, 0x82, 0x68, 0xa7, 0xbc, 0x39 }; | 537 static const uint8_t data[] = { |
| 538 0x16, 0xf2, 0xbb, 0x82, 0x68, 0xa7, 0xbc, 0x39 |
| 539 }; |
532 ByteReader reader(ENDIANNESS_BIG); | 540 ByteReader reader(ENDIANNESS_BIG); |
533 reader.SetAddressSize(8); | 541 reader.SetAddressSize(8); |
534 reader.SetDataBase(0xbef308bd25ce74f0ULL); | 542 reader.SetDataBase(0xbef308bd25ce74f0ULL); |
535 DwarfPointerEncoding encoding = | 543 DwarfPointerEncoding encoding = |
536 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_datarel | 544 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_datarel |
537 | dwarf2reader::DW_EH_PE_sleb128); | 545 | dwarf2reader::DW_EH_PE_sleb128); |
538 EXPECT_EQ(0xbef308bd25ce74f0ULL + 0xfffffffffffa013bULL, | 546 EXPECT_EQ(0xbef308bd25ce74f0ULL + 0xfffffffffffa013bULL, |
539 reader.ReadEncodedPointer(data + 2, encoding, &pointer_size)); | 547 reader.ReadEncodedPointer(data + 2, encoding, &pointer_size)); |
540 EXPECT_EQ(3U, pointer_size); | 548 EXPECT_EQ(3U, pointer_size); |
541 } | 549 } |
542 | 550 |
543 TEST_F(Reader, DW_EH_PE_funcrel) { | 551 TEST_F(Reader, DW_EH_PE_funcrel) { |
544 static const char data[] = { 0x84, 0xf8, 0x14, 0x01, 0x61, 0xd1, 0x48, 0xc9 }; | 552 static const uint8_t data[] = { |
| 553 0x84, 0xf8, 0x14, 0x01, 0x61, 0xd1, 0x48, 0xc9 |
| 554 }; |
545 ByteReader reader(ENDIANNESS_BIG); | 555 ByteReader reader(ENDIANNESS_BIG); |
546 reader.SetAddressSize(4); | 556 reader.SetAddressSize(4); |
547 reader.SetFunctionBase(0x823c3520); | 557 reader.SetFunctionBase(0x823c3520); |
548 DwarfPointerEncoding encoding = | 558 DwarfPointerEncoding encoding = |
549 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_funcrel | 559 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_funcrel |
550 | dwarf2reader::DW_EH_PE_udata2); | 560 | dwarf2reader::DW_EH_PE_udata2); |
551 EXPECT_EQ(0x823c3520 + 0xd148, | 561 EXPECT_EQ(0x823c3520 + 0xd148, |
552 reader.ReadEncodedPointer(data + 5, encoding, &pointer_size)); | 562 reader.ReadEncodedPointer(data + 5, encoding, &pointer_size)); |
553 EXPECT_EQ(2U, pointer_size); | 563 EXPECT_EQ(2U, pointer_size); |
554 } | 564 } |
555 | 565 |
556 TEST(UsableBase, CFI) { | 566 TEST(UsableBase, CFI) { |
557 static const char data[1] = { 0x42 }; | 567 static const uint8_t data[] = { 0x42 }; |
558 ByteReader reader(ENDIANNESS_BIG); | 568 ByteReader reader(ENDIANNESS_BIG); |
559 reader.SetCFIDataBase(0xb31cbd20, data); | 569 reader.SetCFIDataBase(0xb31cbd20, data); |
560 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr)); | 570 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr)); |
561 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel)); | 571 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel)); |
562 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel)); | 572 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel)); |
563 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel)); | 573 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel)); |
564 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel)); | 574 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel)); |
565 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit)); | 575 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit)); |
566 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60))); | 576 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60))); |
567 } | 577 } |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
610 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel)); | 620 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel)); |
611 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel)); | 621 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel)); |
612 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel)); | 622 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel)); |
613 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel)); | 623 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel)); |
614 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit)); | 624 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit)); |
615 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60))); | 625 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60))); |
616 } | 626 } |
617 | 627 |
618 struct AlignedFixture { | 628 struct AlignedFixture { |
619 AlignedFixture() : reader(ENDIANNESS_BIG) { reader.SetAddressSize(4); } | 629 AlignedFixture() : reader(ENDIANNESS_BIG) { reader.SetAddressSize(4); } |
620 static const char data[10]; | 630 static const uint8_t data[10]; |
621 ByteReader reader; | 631 ByteReader reader; |
622 size_t pointer_size; | 632 size_t pointer_size; |
623 }; | 633 }; |
624 | 634 |
625 const char AlignedFixture::data[10] = { | 635 const uint8_t AlignedFixture::data[10] = { |
626 0xfe, 0x6e, 0x93, 0xd8, 0x34, 0xd5, 0x1c, 0xd3, 0xac, 0x2b | 636 0xfe, 0x6e, 0x93, 0xd8, 0x34, 0xd5, 0x1c, 0xd3, 0xac, 0x2b |
627 }; | 637 }; |
628 | 638 |
629 class Aligned: public AlignedFixture, public Test { }; | 639 class Aligned: public AlignedFixture, public Test { }; |
630 | 640 |
631 TEST_F(Aligned, DW_EH_PE_aligned0) { | 641 TEST_F(Aligned, DW_EH_PE_aligned0) { |
632 reader.SetCFIDataBase(0xb440305c, data); | 642 reader.SetCFIDataBase(0xb440305c, data); |
633 EXPECT_EQ(0xfe6e93d8U, | 643 EXPECT_EQ(0xfe6e93d8U, |
634 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned, | 644 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned, |
635 &pointer_size)); | 645 &pointer_size)); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
688 } | 698 } |
689 | 699 |
690 TEST_F(Aligned, DW_EH_PE_aligned03) { | 700 TEST_F(Aligned, DW_EH_PE_aligned03) { |
691 reader.SetCFIDataBase(0xb4403064, data); | 701 reader.SetCFIDataBase(0xb4403064, data); |
692 EXPECT_EQ(0x34d51cd3U, | 702 EXPECT_EQ(0x34d51cd3U, |
693 reader.ReadEncodedPointer(data + 3, | 703 reader.ReadEncodedPointer(data + 3, |
694 dwarf2reader::DW_EH_PE_aligned, | 704 dwarf2reader::DW_EH_PE_aligned, |
695 &pointer_size)); | 705 &pointer_size)); |
696 EXPECT_EQ(5U, pointer_size); | 706 EXPECT_EQ(5U, pointer_size); |
697 } | 707 } |
OLD | NEW |