Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(441)

Side by Side Diff: src/common/dwarf/bytereader_unittest.cc

Issue 1605153004: unittests: fix -Wnarrowing build errors (Closed) Base URL: https://chromium.googlesource.com/breakpad/breakpad.git@master
Patch Set: back to stdint.h Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/common/dwarf/bytereader-inl.h ('k') | src/common/dwarf/dwarf2diehandler.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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 }
OLDNEW
« no previous file with comments | « src/common/dwarf/bytereader-inl.h ('k') | src/common/dwarf/dwarf2diehandler.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698