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

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: convert to uint8_t 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
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 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
64 CFISection section(kBigEndian, 4); 64 CFISection section(kBigEndian, 4);
65 section 65 section
66 .D8(0xc0) 66 .D8(0xc0)
67 .D16(0xcf0d) 67 .D16(0xcf0d)
68 .D32(0x96fdd219) 68 .D32(0x96fdd219)
69 .D64(0xbbf55fef0825f117ULL) 69 .D64(0xbbf55fef0825f117ULL)
70 .ULEB128(0xa0927048ba8121afULL) 70 .ULEB128(0xa0927048ba8121afULL)
71 .LEB128(-0x4f337badf4483f83LL) 71 .LEB128(-0x4f337badf4483f83LL)
72 .D32(0xfec319c9); 72 .D32(0xfec319c9);
73 ASSERT_TRUE(section.GetContents(&contents)); 73 ASSERT_TRUE(section.GetContents(&contents));
74 const char *data = contents.data(); 74 const uint8_t *data = reinterpret_cast<const uint8_t *>(contents.data());
75 EXPECT_EQ(0xc0U, reader.ReadOneByte(data)); 75 EXPECT_EQ(0xc0U, reader.ReadOneByte(data));
76 EXPECT_EQ(0xcf0dU, reader.ReadTwoBytes(data + 1)); 76 EXPECT_EQ(0xcf0dU, reader.ReadTwoBytes(data + 1));
77 EXPECT_EQ(0x96fdd219U, reader.ReadFourBytes(data + 3)); 77 EXPECT_EQ(0x96fdd219U, reader.ReadFourBytes(data + 3));
78 EXPECT_EQ(0xbbf55fef0825f117ULL, reader.ReadEightBytes(data + 7)); 78 EXPECT_EQ(0xbbf55fef0825f117ULL, reader.ReadEightBytes(data + 7));
79 size_t leb128_size; 79 size_t leb128_size;
80 EXPECT_EQ(0xa0927048ba8121afULL, 80 EXPECT_EQ(0xa0927048ba8121afULL,
81 reader.ReadUnsignedLEB128(data + 15, &leb128_size)); 81 reader.ReadUnsignedLEB128(data + 15, &leb128_size));
82 EXPECT_EQ(10U, leb128_size); 82 EXPECT_EQ(10U, leb128_size);
83 EXPECT_EQ(-0x4f337badf4483f83LL, 83 EXPECT_EQ(-0x4f337badf4483f83LL,
84 reader.ReadSignedLEB128(data + 25, &leb128_size)); 84 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))); 368 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0d)));
369 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0f))); 369 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0f)));
370 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x51))); 370 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x51)));
371 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x60))); 371 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x60)));
372 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x70))); 372 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x70)));
373 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xf0))); 373 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xf0)));
374 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xd0))); 374 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xd0)));
375 } 375 }
376 376
377 TEST_F(ReaderDeathTest, DW_EH_PE_omit) { 377 TEST_F(ReaderDeathTest, DW_EH_PE_omit) {
378 static const char data[1] = { 42 }; 378 static const uint8_t data[] = { 42 };
379 ByteReader reader(ENDIANNESS_BIG); 379 ByteReader reader(ENDIANNESS_BIG);
380 reader.SetAddressSize(4); 380 reader.SetAddressSize(4);
381 EXPECT_DEATH(reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_omit, 381 EXPECT_DEATH(reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_omit,
382 &pointer_size), 382 &pointer_size),
383 "encoding != DW_EH_PE_omit"); 383 "encoding != DW_EH_PE_omit");
384 } 384 }
385 385
386 TEST_F(Reader, DW_EH_PE_absptr4) { 386 TEST_F(Reader, DW_EH_PE_absptr4) {
387 static const char data[] = { 0x27, 0x57, 0xea, 0x40 }; 387 static const uint8_t data[] = { 0x27, 0x57, 0xea, 0x40 };
388 ByteReader reader(ENDIANNESS_LITTLE); 388 ByteReader reader(ENDIANNESS_LITTLE);
389 reader.SetAddressSize(4); 389 reader.SetAddressSize(4);
390 EXPECT_EQ(0x40ea5727U, 390 EXPECT_EQ(0x40ea5727U,
391 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_absptr, 391 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_absptr,
392 &pointer_size)); 392 &pointer_size));
393 EXPECT_EQ(4U, pointer_size); 393 EXPECT_EQ(4U, pointer_size);
394 } 394 }
395 395
396 TEST_F(Reader, DW_EH_PE_absptr8) { 396 TEST_F(Reader, DW_EH_PE_absptr8) {
397 static const char data[] = { 397 static const uint8_t data[] = {
398 0x60, 0x27, 0x57, 0xea, 0x40, 0xc2, 0x98, 0x05, 0x01, 0x50 398 0x60, 0x27, 0x57, 0xea, 0x40, 0xc2, 0x98, 0x05, 0x01, 0x50
399 }; 399 };
400 ByteReader reader(ENDIANNESS_LITTLE); 400 ByteReader reader(ENDIANNESS_LITTLE);
401 reader.SetAddressSize(8); 401 reader.SetAddressSize(8);
402 EXPECT_EQ(0x010598c240ea5727ULL, 402 EXPECT_EQ(0x010598c240ea5727ULL,
403 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_absptr, 403 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_absptr,
404 &pointer_size)); 404 &pointer_size));
405 EXPECT_EQ(8U, pointer_size); 405 EXPECT_EQ(8U, pointer_size);
406 } 406 }
407 407
408 TEST_F(Reader, DW_EH_PE_uleb128) { 408 TEST_F(Reader, DW_EH_PE_uleb128) {
409 static const char data[] = { 0x81, 0x84, 0x4c }; 409 static const uint8_t data[] = { 0x81, 0x84, 0x4c };
410 ByteReader reader(ENDIANNESS_LITTLE); 410 ByteReader reader(ENDIANNESS_LITTLE);
411 reader.SetAddressSize(4); 411 reader.SetAddressSize(4);
412 EXPECT_EQ(0x130201U, 412 EXPECT_EQ(0x130201U,
413 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_uleb128, 413 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_uleb128,
414 &pointer_size)); 414 &pointer_size));
415 EXPECT_EQ(3U, pointer_size); 415 EXPECT_EQ(3U, pointer_size);
416 } 416 }
417 417
418 TEST_F(Reader, DW_EH_PE_udata2) { 418 TEST_F(Reader, DW_EH_PE_udata2) {
419 static const char data[] = { 0xf4, 0x8d }; 419 static const uint8_t data[] = { 0xf4, 0x8d };
420 ByteReader reader(ENDIANNESS_BIG); 420 ByteReader reader(ENDIANNESS_BIG);
421 reader.SetAddressSize(4); 421 reader.SetAddressSize(4);
422 EXPECT_EQ(0xf48dU, 422 EXPECT_EQ(0xf48dU,
423 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_udata2, 423 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_udata2,
424 &pointer_size)); 424 &pointer_size));
425 EXPECT_EQ(2U, pointer_size); 425 EXPECT_EQ(2U, pointer_size);
426 } 426 }
427 427
428 TEST_F(Reader, DW_EH_PE_udata4) { 428 TEST_F(Reader, DW_EH_PE_udata4) {
429 static const char data[] = { 0xb2, 0x68, 0xa5, 0x62, 0x8f, 0x8b }; 429 static const uint8_t data[] = { 0xb2, 0x68, 0xa5, 0x62, 0x8f, 0x8b };
430 ByteReader reader(ENDIANNESS_BIG); 430 ByteReader reader(ENDIANNESS_BIG);
431 reader.SetAddressSize(8); 431 reader.SetAddressSize(8);
432 EXPECT_EQ(0xa5628f8b, 432 EXPECT_EQ(0xa5628f8b,
433 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_udata4, 433 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_udata4,
434 &pointer_size)); 434 &pointer_size));
435 EXPECT_EQ(4U, pointer_size); 435 EXPECT_EQ(4U, pointer_size);
436 } 436 }
437 437
438 TEST_F(Reader, DW_EH_PE_udata8Addr8) { 438 TEST_F(Reader, DW_EH_PE_udata8Addr8) {
439 static const char data[] = { 439 static const uint8_t data[] = {
440 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe 440 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe
441 }; 441 };
442 ByteReader reader(ENDIANNESS_LITTLE); 442 ByteReader reader(ENDIANNESS_LITTLE);
443 reader.SetAddressSize(8); 443 reader.SetAddressSize(8);
444 EXPECT_EQ(0x8fed199f69047304ULL, 444 EXPECT_EQ(0x8fed199f69047304ULL,
445 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8, 445 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8,
446 &pointer_size)); 446 &pointer_size));
447 EXPECT_EQ(8U, pointer_size); 447 EXPECT_EQ(8U, pointer_size);
448 } 448 }
449 449
450 TEST_F(Reader, DW_EH_PE_udata8Addr4) { 450 TEST_F(Reader, DW_EH_PE_udata8Addr4) {
451 static const char data[] = { 451 static const uint8_t data[] = {
452 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe 452 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe
453 }; 453 };
454 ByteReader reader(ENDIANNESS_LITTLE); 454 ByteReader reader(ENDIANNESS_LITTLE);
455 reader.SetAddressSize(4); 455 reader.SetAddressSize(4);
456 EXPECT_EQ(0x69047304ULL, 456 EXPECT_EQ(0x69047304ULL,
457 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8, 457 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8,
458 &pointer_size)); 458 &pointer_size));
459 EXPECT_EQ(8U, pointer_size); 459 EXPECT_EQ(8U, pointer_size);
460 } 460 }
461 461
462 TEST_F(Reader, DW_EH_PE_sleb128) { 462 TEST_F(Reader, DW_EH_PE_sleb128) {
463 static const char data[] = { 0x42, 0xff, 0xfb, 0x73 }; 463 static const uint8_t data[] = { 0x42, 0xff, 0xfb, 0x73 };
464 ByteReader reader(ENDIANNESS_BIG); 464 ByteReader reader(ENDIANNESS_BIG);
465 reader.SetAddressSize(4); 465 reader.SetAddressSize(4);
466 EXPECT_EQ(-0x030201U & 0xffffffff, 466 EXPECT_EQ(-0x030201U & 0xffffffff,
467 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sleb128, 467 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sleb128,
468 &pointer_size)); 468 &pointer_size));
469 EXPECT_EQ(3U, pointer_size); 469 EXPECT_EQ(3U, pointer_size);
470 } 470 }
471 471
472 TEST_F(Reader, DW_EH_PE_sdata2) { 472 TEST_F(Reader, DW_EH_PE_sdata2) {
473 static const char data[] = { 0xb9, 0xbf }; 473 static const uint8_t data[] = { 0xb9, 0xbf };
474 ByteReader reader(ENDIANNESS_LITTLE); 474 ByteReader reader(ENDIANNESS_LITTLE);
475 reader.SetAddressSize(8); 475 reader.SetAddressSize(8);
476 EXPECT_EQ(0xffffffffffffbfb9ULL, 476 EXPECT_EQ(0xffffffffffffbfb9ULL,
477 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_sdata2, 477 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_sdata2,
478 &pointer_size)); 478 &pointer_size));
479 EXPECT_EQ(2U, pointer_size); 479 EXPECT_EQ(2U, pointer_size);
480 } 480 }
481 481
482 TEST_F(Reader, DW_EH_PE_sdata4) { 482 TEST_F(Reader, DW_EH_PE_sdata4) {
483 static const char data[] = { 0xa0, 0xca, 0xf2, 0xb8, 0xc2, 0xad }; 483 static const uint8_t data[] = { 0xa0, 0xca, 0xf2, 0xb8, 0xc2, 0xad };
484 ByteReader reader(ENDIANNESS_LITTLE); 484 ByteReader reader(ENDIANNESS_LITTLE);
485 reader.SetAddressSize(8); 485 reader.SetAddressSize(8);
486 EXPECT_EQ(0xffffffffadc2b8f2ULL, 486 EXPECT_EQ(0xffffffffadc2b8f2ULL,
487 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_sdata4, 487 reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_sdata4,
488 &pointer_size)); 488 &pointer_size));
489 EXPECT_EQ(4U, pointer_size); 489 EXPECT_EQ(4U, pointer_size);
490 } 490 }
491 491
492 TEST_F(Reader, DW_EH_PE_sdata8) { 492 TEST_F(Reader, DW_EH_PE_sdata8) {
493 static const char data[] = { 493 static const uint8_t data[] = {
494 0xf6, 0x66, 0x57, 0x79, 0xe0, 0x0c, 0x9b, 0x26, 0x87 494 0xf6, 0x66, 0x57, 0x79, 0xe0, 0x0c, 0x9b, 0x26, 0x87
495 }; 495 };
496 ByteReader reader(ENDIANNESS_LITTLE); 496 ByteReader reader(ENDIANNESS_LITTLE);
497 reader.SetAddressSize(8); 497 reader.SetAddressSize(8);
498 EXPECT_EQ(0x87269b0ce0795766ULL, 498 EXPECT_EQ(0x87269b0ce0795766ULL,
499 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sdata8, 499 reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sdata8,
500 &pointer_size)); 500 &pointer_size));
501 EXPECT_EQ(8U, pointer_size); 501 EXPECT_EQ(8U, pointer_size);
502 } 502 }
503 503
504 TEST_F(Reader, DW_EH_PE_pcrel) { 504 TEST_F(Reader, DW_EH_PE_pcrel) {
505 static const char data[] = { 0x4a, 0x8b, 0x1b, 0x14, 0xc8, 0xc4, 0x02, 0xce }; 505 static const uint8_t data[] = { 0x4a, 0x8b, 0x1b, 0x14, 0xc8, 0xc4, 0x02, 0xce };
Mark Mentovai 2016/01/25 15:08:43 This and the next few ones go past 80 characters n
506 ByteReader reader(ENDIANNESS_BIG); 506 ByteReader reader(ENDIANNESS_BIG);
507 reader.SetAddressSize(4); 507 reader.SetAddressSize(4);
508 DwarfPointerEncoding encoding = 508 DwarfPointerEncoding encoding =
509 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_pcrel 509 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_pcrel
510 | dwarf2reader::DW_EH_PE_absptr); 510 | dwarf2reader::DW_EH_PE_absptr);
511 reader.SetCFIDataBase(0x89951377, data); 511 reader.SetCFIDataBase(0x89951377, data);
512 EXPECT_EQ(0x89951377 + 3 + 0x14c8c402, 512 EXPECT_EQ(0x89951377 + 3 + 0x14c8c402,
513 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size)); 513 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size));
514 EXPECT_EQ(4U, pointer_size); 514 EXPECT_EQ(4U, pointer_size);
515 } 515 }
516 516
517 TEST_F(Reader, DW_EH_PE_textrel) { 517 TEST_F(Reader, DW_EH_PE_textrel) {
518 static const char data[] = { 0xd9, 0x0d, 0x05, 0x17, 0xc9, 0x7a, 0x42, 0x1e }; 518 static const uint8_t data[] = { 0xd9, 0x0d, 0x05, 0x17, 0xc9, 0x7a, 0x42, 0x1e };
519 ByteReader reader(ENDIANNESS_LITTLE); 519 ByteReader reader(ENDIANNESS_LITTLE);
520 reader.SetAddressSize(4); 520 reader.SetAddressSize(4);
521 reader.SetTextBase(0xb91beaf0); 521 reader.SetTextBase(0xb91beaf0);
522 DwarfPointerEncoding encoding = 522 DwarfPointerEncoding encoding =
523 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_textrel 523 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_textrel
524 | dwarf2reader::DW_EH_PE_sdata2); 524 | dwarf2reader::DW_EH_PE_sdata2);
525 EXPECT_EQ((0xb91beaf0 + 0xffffc917) & 0xffffffff, 525 EXPECT_EQ((0xb91beaf0 + 0xffffc917) & 0xffffffff,
526 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size)); 526 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size));
527 EXPECT_EQ(2U, pointer_size); 527 EXPECT_EQ(2U, pointer_size);
528 } 528 }
529 529
530 TEST_F(Reader, DW_EH_PE_datarel) { 530 TEST_F(Reader, DW_EH_PE_datarel) {
531 static const char data[] = { 0x16, 0xf2, 0xbb, 0x82, 0x68, 0xa7, 0xbc, 0x39 }; 531 static const uint8_t data[] = { 0x16, 0xf2, 0xbb, 0x82, 0x68, 0xa7, 0xbc, 0x39 };
532 ByteReader reader(ENDIANNESS_BIG); 532 ByteReader reader(ENDIANNESS_BIG);
533 reader.SetAddressSize(8); 533 reader.SetAddressSize(8);
534 reader.SetDataBase(0xbef308bd25ce74f0ULL); 534 reader.SetDataBase(0xbef308bd25ce74f0ULL);
535 DwarfPointerEncoding encoding = 535 DwarfPointerEncoding encoding =
536 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_datarel 536 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_datarel
537 | dwarf2reader::DW_EH_PE_sleb128); 537 | dwarf2reader::DW_EH_PE_sleb128);
538 EXPECT_EQ(0xbef308bd25ce74f0ULL + 0xfffffffffffa013bULL, 538 EXPECT_EQ(0xbef308bd25ce74f0ULL + 0xfffffffffffa013bULL,
539 reader.ReadEncodedPointer(data + 2, encoding, &pointer_size)); 539 reader.ReadEncodedPointer(data + 2, encoding, &pointer_size));
540 EXPECT_EQ(3U, pointer_size); 540 EXPECT_EQ(3U, pointer_size);
541 } 541 }
542 542
543 TEST_F(Reader, DW_EH_PE_funcrel) { 543 TEST_F(Reader, DW_EH_PE_funcrel) {
544 static const char data[] = { 0x84, 0xf8, 0x14, 0x01, 0x61, 0xd1, 0x48, 0xc9 }; 544 static const uint8_t data[] = { 0x84, 0xf8, 0x14, 0x01, 0x61, 0xd1, 0x48, 0xc9 };
545 ByteReader reader(ENDIANNESS_BIG); 545 ByteReader reader(ENDIANNESS_BIG);
546 reader.SetAddressSize(4); 546 reader.SetAddressSize(4);
547 reader.SetFunctionBase(0x823c3520); 547 reader.SetFunctionBase(0x823c3520);
548 DwarfPointerEncoding encoding = 548 DwarfPointerEncoding encoding =
549 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_funcrel 549 DwarfPointerEncoding(dwarf2reader::DW_EH_PE_funcrel
550 | dwarf2reader::DW_EH_PE_udata2); 550 | dwarf2reader::DW_EH_PE_udata2);
551 EXPECT_EQ(0x823c3520 + 0xd148, 551 EXPECT_EQ(0x823c3520 + 0xd148,
552 reader.ReadEncodedPointer(data + 5, encoding, &pointer_size)); 552 reader.ReadEncodedPointer(data + 5, encoding, &pointer_size));
553 EXPECT_EQ(2U, pointer_size); 553 EXPECT_EQ(2U, pointer_size);
554 } 554 }
555 555
556 TEST(UsableBase, CFI) { 556 TEST(UsableBase, CFI) {
557 static const char data[1] = { 0x42 }; 557 static const uint8_t data[] = { 0x42 };
558 ByteReader reader(ENDIANNESS_BIG); 558 ByteReader reader(ENDIANNESS_BIG);
559 reader.SetCFIDataBase(0xb31cbd20, data); 559 reader.SetCFIDataBase(0xb31cbd20, data);
560 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr)); 560 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr));
561 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel)); 561 EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel));
562 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel)); 562 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel));
563 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel)); 563 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel));
564 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel)); 564 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel));
565 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit)); 565 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit));
566 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60))); 566 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
567 } 567 }
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
610 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel)); 610 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel));
611 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel)); 611 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel));
612 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel)); 612 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel));
613 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel)); 613 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel));
614 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit)); 614 EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit));
615 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60))); 615 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
616 } 616 }
617 617
618 struct AlignedFixture { 618 struct AlignedFixture {
619 AlignedFixture() : reader(ENDIANNESS_BIG) { reader.SetAddressSize(4); } 619 AlignedFixture() : reader(ENDIANNESS_BIG) { reader.SetAddressSize(4); }
620 static const char data[10]; 620 static const uint8_t data[10];
621 ByteReader reader; 621 ByteReader reader;
622 size_t pointer_size; 622 size_t pointer_size;
623 }; 623 };
624 624
625 const char AlignedFixture::data[10] = { 625 const uint8_t AlignedFixture::data[10] = {
626 0xfe, 0x6e, 0x93, 0xd8, 0x34, 0xd5, 0x1c, 0xd3, 0xac, 0x2b 626 0xfe, 0x6e, 0x93, 0xd8, 0x34, 0xd5, 0x1c, 0xd3, 0xac, 0x2b
627 }; 627 };
628 628
629 class Aligned: public AlignedFixture, public Test { }; 629 class Aligned: public AlignedFixture, public Test { };
630 630
631 TEST_F(Aligned, DW_EH_PE_aligned0) { 631 TEST_F(Aligned, DW_EH_PE_aligned0) {
632 reader.SetCFIDataBase(0xb440305c, data); 632 reader.SetCFIDataBase(0xb440305c, data);
633 EXPECT_EQ(0xfe6e93d8U, 633 EXPECT_EQ(0xfe6e93d8U,
634 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned, 634 reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned,
635 &pointer_size)); 635 &pointer_size));
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
688 } 688 }
689 689
690 TEST_F(Aligned, DW_EH_PE_aligned03) { 690 TEST_F(Aligned, DW_EH_PE_aligned03) {
691 reader.SetCFIDataBase(0xb4403064, data); 691 reader.SetCFIDataBase(0xb4403064, data);
692 EXPECT_EQ(0x34d51cd3U, 692 EXPECT_EQ(0x34d51cd3U,
693 reader.ReadEncodedPointer(data + 3, 693 reader.ReadEncodedPointer(data + 3,
694 dwarf2reader::DW_EH_PE_aligned, 694 dwarf2reader::DW_EH_PE_aligned,
695 &pointer_size)); 695 &pointer_size));
696 EXPECT_EQ(5U, pointer_size); 696 EXPECT_EQ(5U, pointer_size);
697 } 697 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698