elfdump.c (295577) | elfdump.c (300311) |
---|---|
1/*- 2 * Copyright (c) 2007-2012 Kai Wang 3 * Copyright (c) 2003 David O'Brien. All rights reserved. 4 * Copyright (c) 2001 Jake Burkholder 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions --- 36 unchanged lines hidden (view full) --- 45 46#ifdef USE_LIBARCHIVE_AR 47#include <archive.h> 48#include <archive_entry.h> 49#endif 50 51#include "_elftc.h" 52 | 1/*- 2 * Copyright (c) 2007-2012 Kai Wang 3 * Copyright (c) 2003 David O'Brien. All rights reserved. 4 * Copyright (c) 2001 Jake Burkholder 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions --- 36 unchanged lines hidden (view full) --- 45 46#ifdef USE_LIBARCHIVE_AR 47#include <archive.h> 48#include <archive_entry.h> 49#endif 50 51#include "_elftc.h" 52 |
53ELFTC_VCSID("$Id: elfdump.c 3391 2016-02-05 19:43:01Z emaste $"); | 53ELFTC_VCSID("$Id: elfdump.c 3474 2016-05-17 20:44:53Z emaste $"); |
54 55#if defined(ELFTC_NEED_ELF_NOTE_DEFINITION) 56#include "native-elf-format.h" 57#if ELFTC_CLASS == ELFCLASS32 58typedef Elf32_Nhdr Elf_Note; 59#else 60typedef Elf64_Nhdr Elf_Note; 61#endif --- 196 unchanged lines hidden (view full) --- 258 case EM_AARCH64:return "EM_AARCH64"; 259 case EM_RISCV: return "EM_RISCV"; 260 } 261 snprintf(machdesc, sizeof(machdesc), 262 "(unknown machine) -- type 0x%x", mach); 263 return (machdesc); 264} 265 | 54 55#if defined(ELFTC_NEED_ELF_NOTE_DEFINITION) 56#include "native-elf-format.h" 57#if ELFTC_CLASS == ELFCLASS32 58typedef Elf32_Nhdr Elf_Note; 59#else 60typedef Elf64_Nhdr Elf_Note; 61#endif --- 196 unchanged lines hidden (view full) --- 258 case EM_AARCH64:return "EM_AARCH64"; 259 case EM_RISCV: return "EM_RISCV"; 260 } 261 snprintf(machdesc, sizeof(machdesc), 262 "(unknown machine) -- type 0x%x", mach); 263 return (machdesc); 264} 265 |
266static const char *e_types[] = { 267 "ET_NONE", "ET_REL", "ET_EXEC", "ET_DYN", "ET_CORE" 268}; | 266static const char * 267elf_type_str(unsigned int type) 268{ 269 static char s_type[32]; |
269 | 270 |
270static const char *ei_versions[] = { 271 "EV_NONE", "EV_CURRENT" 272}; | 271 switch (type) 272 { 273 case ET_NONE: return "ET_NONE"; 274 case ET_REL: return "ET_REL"; 275 case ET_EXEC: return "ET_EXEC"; 276 case ET_DYN: return "ET_DYN"; 277 case ET_CORE: return "ET_CORE"; 278 } 279 if (type >= ET_LOPROC) 280 snprintf(s_type, sizeof(s_type), "<proc: %#x>", type); 281 else if (type >= ET_LOOS && type <= ET_HIOS) 282 snprintf(s_type, sizeof(s_type), "<os: %#x>", type); 283 else 284 snprintf(s_type, sizeof(s_type), "<unknown: %#x", type); 285 return (s_type); 286} |
273 | 287 |
274static const char *ei_classes[] = { 275 "ELFCLASSNONE", "ELFCLASS32", "ELFCLASS64" 276}; | 288static const char * 289elf_version_str(unsigned int ver) 290{ 291 static char s_ver[32]; |
277 | 292 |
278static const char *ei_data[] = { 279 "ELFDATANONE", "ELFDATA2LSB", "ELFDATA2MSB" 280}; | 293 switch (ver) { 294 case EV_NONE: return "EV_NONE"; 295 case EV_CURRENT: return "EV_CURRENT"; 296 } 297 snprintf(s_ver, sizeof(s_ver), "<unknown: %#x>", ver); 298 return (s_ver); 299} |
281 | 300 |
301static const char * 302elf_class_str(unsigned int class) 303{ 304 static char s_class[32]; 305 306 switch (class) { 307 case ELFCLASSNONE: return "ELFCLASSNONE"; 308 case ELFCLASS32: return "ELFCLASS32"; 309 case ELFCLASS64: return "ELFCLASS64"; 310 } 311 snprintf(s_class, sizeof(s_class), "<unknown: %#x>", class); 312 return (s_class); 313} 314 315static const char * 316elf_data_str(unsigned int data) 317{ 318 static char s_data[32]; 319 320 switch (data) { 321 case ELFDATANONE: return "ELFDATANONE"; 322 case ELFDATA2LSB: return "ELFDATA2LSB"; 323 case ELFDATA2MSB: return "ELFDATA2MSB"; 324 } 325 snprintf(s_data, sizeof(s_data), "<unknown: %#x>", data); 326 return (s_data); 327} 328 |
|
282static const char *ei_abis[256] = { 283 "ELFOSABI_NONE", "ELFOSABI_HPUX", "ELFOSABI_NETBSD", "ELFOSABI_LINUX", 284 "ELFOSABI_HURD", "ELFOSABI_86OPEN", "ELFOSABI_SOLARIS", "ELFOSABI_AIX", 285 "ELFOSABI_IRIX", "ELFOSABI_FREEBSD", "ELFOSABI_TRU64", 286 "ELFOSABI_MODESTO", "ELFOSABI_OPENBSD", | 329static const char *ei_abis[256] = { 330 "ELFOSABI_NONE", "ELFOSABI_HPUX", "ELFOSABI_NETBSD", "ELFOSABI_LINUX", 331 "ELFOSABI_HURD", "ELFOSABI_86OPEN", "ELFOSABI_SOLARIS", "ELFOSABI_AIX", 332 "ELFOSABI_IRIX", "ELFOSABI_FREEBSD", "ELFOSABI_TRU64", 333 "ELFOSABI_MODESTO", "ELFOSABI_OPENBSD", |
334 [17] = "ELFOSABI_CLOUDABI", |
|
287 [255] = "ELFOSABI_STANDALONE" 288}; 289 | 335 [255] = "ELFOSABI_STANDALONE" 336}; 337 |
290static const char *p_types[] = { 291 "PT_NULL", "PT_LOAD", "PT_DYNAMIC", "PT_INTERP", "PT_NOTE", 292 "PT_SHLIB", "PT_PHDR", "PT_TLS" 293}; | 338static const char * 339elf_phdr_type_str(unsigned int type) 340{ 341 static char s_type[32]; |
294 | 342 |
343 switch (type) { 344 case PT_NULL: return "PT_NULL"; 345 case PT_LOAD: return "PT_LOAD"; 346 case PT_DYNAMIC: return "PT_DYNAMIC"; 347 case PT_INTERP: return "PT_INTERP"; 348 case PT_NOTE: return "PT_NOTE"; 349 case PT_SHLIB: return "PT_SHLIB"; 350 case PT_PHDR: return "PT_PHDR"; 351 case PT_TLS: return "PT_TLS"; 352 case PT_GNU_EH_FRAME: return "PT_GNU_EH_FRAME"; 353 case PT_GNU_STACK: return "PT_GNU_STACK"; 354 case PT_GNU_RELRO: return "PT_GNU_RELRO"; 355 } 356 snprintf(s_type, sizeof(s_type), "<unknown: %#x>", type); 357 return (s_type); 358} 359 |
|
295static const char *p_flags[] = { 296 "", "PF_X", "PF_W", "PF_X|PF_W", "PF_R", "PF_X|PF_R", "PF_W|PF_R", 297 "PF_X|PF_W|PF_R" 298}; 299 300static const char * 301sh_name(struct elfdump *ed, int ndx) 302{ --- 99 unchanged lines hidden (view full) --- 402 DEFINE_SHF(ALLOC) \ 403 DEFINE_SHF(EXECINSTR) \ 404 DEFINE_SHF(MERGE) \ 405 DEFINE_SHF(STRINGS) \ 406 DEFINE_SHF(INFO_LINK) \ 407 DEFINE_SHF(LINK_ORDER) \ 408 DEFINE_SHF(OS_NONCONFORMING) \ 409 DEFINE_SHF(GROUP) \ | 360static const char *p_flags[] = { 361 "", "PF_X", "PF_W", "PF_X|PF_W", "PF_R", "PF_X|PF_R", "PF_W|PF_R", 362 "PF_X|PF_W|PF_R" 363}; 364 365static const char * 366sh_name(struct elfdump *ed, int ndx) 367{ --- 99 unchanged lines hidden (view full) --- 467 DEFINE_SHF(ALLOC) \ 468 DEFINE_SHF(EXECINSTR) \ 469 DEFINE_SHF(MERGE) \ 470 DEFINE_SHF(STRINGS) \ 471 DEFINE_SHF(INFO_LINK) \ 472 DEFINE_SHF(LINK_ORDER) \ 473 DEFINE_SHF(OS_NONCONFORMING) \ 474 DEFINE_SHF(GROUP) \ |
410 DEFINE_SHF(TLS) | 475 DEFINE_SHF(TLS) \ 476 DEFINE_SHF(COMPRESSED) |
411 412#undef DEFINE_SHF 413#define DEFINE_SHF(F) "SHF_" #F "|" 414#define ALLSHFLAGS DEFINE_SHFLAGS() 415 416static const char * 417sh_flags(uint64_t shf) 418{ --- 94 unchanged lines hidden (view full) --- 513 return (s_sbind); 514 } 515} 516 517static unsigned char st_others[] = { 518 'D', 'I', 'H', 'P' 519}; 520 | 477 478#undef DEFINE_SHF 479#define DEFINE_SHF(F) "SHF_" #F "|" 480#define ALLSHFLAGS DEFINE_SHFLAGS() 481 482static const char * 483sh_flags(uint64_t shf) 484{ --- 94 unchanged lines hidden (view full) --- 579 return (s_sbind); 580 } 581} 582 583static unsigned char st_others[] = { 584 'D', 'I', 'H', 'P' 585}; 586 |
521static const char * 522r_type(unsigned int mach, unsigned int type) 523{ 524 switch(mach) { 525 case EM_NONE: return ""; 526 case EM_386: 527 case EM_IAMCU: 528 switch(type) { 529 case 0: return "R_386_NONE"; 530 case 1: return "R_386_32"; 531 case 2: return "R_386_PC32"; 532 case 3: return "R_386_GOT32"; 533 case 4: return "R_386_PLT32"; 534 case 5: return "R_386_COPY"; 535 case 6: return "R_386_GLOB_DAT"; 536 case 7: return "R_386_JUMP_SLOT"; 537 case 8: return "R_386_RELATIVE"; 538 case 9: return "R_386_GOTOFF"; 539 case 10: return "R_386_GOTPC"; 540 case 14: return "R_386_TLS_TPOFF"; 541 case 15: return "R_386_TLS_IE"; 542 case 16: return "R_386_TLS_GOTIE"; 543 case 17: return "R_386_TLS_LE"; 544 case 18: return "R_386_TLS_GD"; 545 case 19: return "R_386_TLS_LDM"; 546 case 24: return "R_386_TLS_GD_32"; 547 case 25: return "R_386_TLS_GD_PUSH"; 548 case 26: return "R_386_TLS_GD_CALL"; 549 case 27: return "R_386_TLS_GD_POP"; 550 case 28: return "R_386_TLS_LDM_32"; 551 case 29: return "R_386_TLS_LDM_PUSH"; 552 case 30: return "R_386_TLS_LDM_CALL"; 553 case 31: return "R_386_TLS_LDM_POP"; 554 case 32: return "R_386_TLS_LDO_32"; 555 case 33: return "R_386_TLS_IE_32"; 556 case 34: return "R_386_TLS_LE_32"; 557 case 35: return "R_386_TLS_DTPMOD32"; 558 case 36: return "R_386_TLS_DTPOFF32"; 559 case 37: return "R_386_TLS_TPOFF32"; 560 default: return ""; 561 } 562 case EM_ARM: 563 switch(type) { 564 case 0: return "R_ARM_NONE"; 565 case 1: return "R_ARM_PC24"; 566 case 2: return "R_ARM_ABS32"; 567 case 3: return "R_ARM_REL32"; 568 case 4: return "R_ARM_PC13"; 569 case 5: return "R_ARM_ABS16"; 570 case 6: return "R_ARM_ABS12"; 571 case 7: return "R_ARM_THM_ABS5"; 572 case 8: return "R_ARM_ABS8"; 573 case 9: return "R_ARM_SBREL32"; 574 case 10: return "R_ARM_THM_PC22"; 575 case 11: return "R_ARM_THM_PC8"; 576 case 12: return "R_ARM_AMP_VCALL9"; 577 case 13: return "R_ARM_SWI24"; 578 case 14: return "R_ARM_THM_SWI8"; 579 case 15: return "R_ARM_XPC25"; 580 case 16: return "R_ARM_THM_XPC22"; 581 case 20: return "R_ARM_COPY"; 582 case 21: return "R_ARM_GLOB_DAT"; 583 case 22: return "R_ARM_JUMP_SLOT"; 584 case 23: return "R_ARM_RELATIVE"; 585 case 24: return "R_ARM_GOTOFF"; 586 case 25: return "R_ARM_GOTPC"; 587 case 26: return "R_ARM_GOT32"; 588 case 27: return "R_ARM_PLT32"; 589 case 100: return "R_ARM_GNU_VTENTRY"; 590 case 101: return "R_ARM_GNU_VTINHERIT"; 591 case 250: return "R_ARM_RSBREL32"; 592 case 251: return "R_ARM_THM_RPC22"; 593 case 252: return "R_ARM_RREL32"; 594 case 253: return "R_ARM_RABS32"; 595 case 254: return "R_ARM_RPC24"; 596 case 255: return "R_ARM_RBASE"; 597 default: return ""; 598 } 599 case EM_IA_64: 600 switch(type) { 601 case 0: return "R_IA_64_NONE"; 602 case 33: return "R_IA_64_IMM14"; 603 case 34: return "R_IA_64_IMM22"; 604 case 35: return "R_IA_64_IMM64"; 605 case 36: return "R_IA_64_DIR32MSB"; 606 case 37: return "R_IA_64_DIR32LSB"; 607 case 38: return "R_IA_64_DIR64MSB"; 608 case 39: return "R_IA_64_DIR64LSB"; 609 case 42: return "R_IA_64_GPREL22"; 610 case 43: return "R_IA_64_GPREL64I"; 611 case 44: return "R_IA_64_GPREL32MSB"; 612 case 45: return "R_IA_64_GPREL32LSB"; 613 case 46: return "R_IA_64_GPREL64MSB"; 614 case 47: return "R_IA_64_GPREL64LSB"; 615 case 50: return "R_IA_64_LTOFF22"; 616 case 51: return "R_IA_64_LTOFF64I"; 617 case 58: return "R_IA_64_PLTOFF22"; 618 case 59: return "R_IA_64_PLTOFF64I"; 619 case 62: return "R_IA_64_PLTOFF64MSB"; 620 case 63: return "R_IA_64_PLTOFF64LSB"; 621 case 67: return "R_IA_64_FPTR64I"; 622 case 68: return "R_IA_64_FPTR32MSB"; 623 case 69: return "R_IA_64_FPTR32LSB"; 624 case 70: return "R_IA_64_FPTR64MSB"; 625 case 71: return "R_IA_64_FPTR64LSB"; 626 case 72: return "R_IA_64_PCREL60B"; 627 case 73: return "R_IA_64_PCREL21B"; 628 case 74: return "R_IA_64_PCREL21M"; 629 case 75: return "R_IA_64_PCREL21F"; 630 case 76: return "R_IA_64_PCREL32MSB"; 631 case 77: return "R_IA_64_PCREL32LSB"; 632 case 78: return "R_IA_64_PCREL64MSB"; 633 case 79: return "R_IA_64_PCREL64LSB"; 634 case 82: return "R_IA_64_LTOFF_FPTR22"; 635 case 83: return "R_IA_64_LTOFF_FPTR64I"; 636 case 84: return "R_IA_64_LTOFF_FPTR32MSB"; 637 case 85: return "R_IA_64_LTOFF_FPTR32LSB"; 638 case 86: return "R_IA_64_LTOFF_FPTR64MSB"; 639 case 87: return "R_IA_64_LTOFF_FPTR64LSB"; 640 case 92: return "R_IA_64_SEGREL32MSB"; 641 case 93: return "R_IA_64_SEGREL32LSB"; 642 case 94: return "R_IA_64_SEGREL64MSB"; 643 case 95: return "R_IA_64_SEGREL64LSB"; 644 case 100: return "R_IA_64_SECREL32MSB"; 645 case 101: return "R_IA_64_SECREL32LSB"; 646 case 102: return "R_IA_64_SECREL64MSB"; 647 case 103: return "R_IA_64_SECREL64LSB"; 648 case 108: return "R_IA_64_REL32MSB"; 649 case 109: return "R_IA_64_REL32LSB"; 650 case 110: return "R_IA_64_REL64MSB"; 651 case 111: return "R_IA_64_REL64LSB"; 652 case 116: return "R_IA_64_LTV32MSB"; 653 case 117: return "R_IA_64_LTV32LSB"; 654 case 118: return "R_IA_64_LTV64MSB"; 655 case 119: return "R_IA_64_LTV64LSB"; 656 case 121: return "R_IA_64_PCREL21BI"; 657 case 122: return "R_IA_64_PCREL22"; 658 case 123: return "R_IA_64_PCREL64I"; 659 case 128: return "R_IA_64_IPLTMSB"; 660 case 129: return "R_IA_64_IPLTLSB"; 661 case 133: return "R_IA_64_SUB"; 662 case 134: return "R_IA_64_LTOFF22X"; 663 case 135: return "R_IA_64_LDXMOV"; 664 case 145: return "R_IA_64_TPREL14"; 665 case 146: return "R_IA_64_TPREL22"; 666 case 147: return "R_IA_64_TPREL64I"; 667 case 150: return "R_IA_64_TPREL64MSB"; 668 case 151: return "R_IA_64_TPREL64LSB"; 669 case 154: return "R_IA_64_LTOFF_TPREL22"; 670 case 166: return "R_IA_64_DTPMOD64MSB"; 671 case 167: return "R_IA_64_DTPMOD64LSB"; 672 case 170: return "R_IA_64_LTOFF_DTPMOD22"; 673 case 177: return "R_IA_64_DTPREL14"; 674 case 178: return "R_IA_64_DTPREL22"; 675 case 179: return "R_IA_64_DTPREL64I"; 676 case 180: return "R_IA_64_DTPREL32MSB"; 677 case 181: return "R_IA_64_DTPREL32LSB"; 678 case 182: return "R_IA_64_DTPREL64MSB"; 679 case 183: return "R_IA_64_DTPREL64LSB"; 680 case 186: return "R_IA_64_LTOFF_DTPREL22"; 681 default: return ""; 682 } 683 case EM_MIPS: 684 switch(type) { 685 case 0: return "R_MIPS_NONE"; 686 case 1: return "R_MIPS_16"; 687 case 2: return "R_MIPS_32"; 688 case 3: return "R_MIPS_REL32"; 689 case 4: return "R_MIPS_26"; 690 case 5: return "R_MIPS_HI16"; 691 case 6: return "R_MIPS_LO16"; 692 case 7: return "R_MIPS_GPREL16"; 693 case 8: return "R_MIPS_LITERAL"; 694 case 9: return "R_MIPS_GOT16"; 695 case 10: return "R_MIPS_PC16"; 696 case 11: return "R_MIPS_CALL16"; 697 case 12: return "R_MIPS_GPREL32"; 698 case 21: return "R_MIPS_GOTHI16"; 699 case 22: return "R_MIPS_GOTLO16"; 700 case 30: return "R_MIPS_CALLHI16"; 701 case 31: return "R_MIPS_CALLLO16"; 702 default: return ""; 703 } 704 case EM_PPC: 705 switch(type) { 706 case 0: return "R_PPC_NONE"; 707 case 1: return "R_PPC_ADDR32"; 708 case 2: return "R_PPC_ADDR24"; 709 case 3: return "R_PPC_ADDR16"; 710 case 4: return "R_PPC_ADDR16_LO"; 711 case 5: return "R_PPC_ADDR16_HI"; 712 case 6: return "R_PPC_ADDR16_HA"; 713 case 7: return "R_PPC_ADDR14"; 714 case 8: return "R_PPC_ADDR14_BRTAKEN"; 715 case 9: return "R_PPC_ADDR14_BRNTAKEN"; 716 case 10: return "R_PPC_REL24"; 717 case 11: return "R_PPC_REL14"; 718 case 12: return "R_PPC_REL14_BRTAKEN"; 719 case 13: return "R_PPC_REL14_BRNTAKEN"; 720 case 14: return "R_PPC_GOT16"; 721 case 15: return "R_PPC_GOT16_LO"; 722 case 16: return "R_PPC_GOT16_HI"; 723 case 17: return "R_PPC_GOT16_HA"; 724 case 18: return "R_PPC_PLTREL24"; 725 case 19: return "R_PPC_COPY"; 726 case 20: return "R_PPC_GLOB_DAT"; 727 case 21: return "R_PPC_JMP_SLOT"; 728 case 22: return "R_PPC_RELATIVE"; 729 case 23: return "R_PPC_LOCAL24PC"; 730 case 24: return "R_PPC_UADDR32"; 731 case 25: return "R_PPC_UADDR16"; 732 case 26: return "R_PPC_REL32"; 733 case 27: return "R_PPC_PLT32"; 734 case 28: return "R_PPC_PLTREL32"; 735 case 29: return "R_PPC_PLT16_LO"; 736 case 30: return "R_PPC_PLT16_HI"; 737 case 31: return "R_PPC_PLT16_HA"; 738 case 32: return "R_PPC_SDAREL16"; 739 case 33: return "R_PPC_SECTOFF"; 740 case 34: return "R_PPC_SECTOFF_LO"; 741 case 35: return "R_PPC_SECTOFF_HI"; 742 case 36: return "R_PPC_SECTOFF_HA"; 743 case 67: return "R_PPC_TLS"; 744 case 68: return "R_PPC_DTPMOD32"; 745 case 69: return "R_PPC_TPREL16"; 746 case 70: return "R_PPC_TPREL16_LO"; 747 case 71: return "R_PPC_TPREL16_HI"; 748 case 72: return "R_PPC_TPREL16_HA"; 749 case 73: return "R_PPC_TPREL32"; 750 case 74: return "R_PPC_DTPREL16"; 751 case 75: return "R_PPC_DTPREL16_LO"; 752 case 76: return "R_PPC_DTPREL16_HI"; 753 case 77: return "R_PPC_DTPREL16_HA"; 754 case 78: return "R_PPC_DTPREL32"; 755 case 79: return "R_PPC_GOT_TLSGD16"; 756 case 80: return "R_PPC_GOT_TLSGD16_LO"; 757 case 81: return "R_PPC_GOT_TLSGD16_HI"; 758 case 82: return "R_PPC_GOT_TLSGD16_HA"; 759 case 83: return "R_PPC_GOT_TLSLD16"; 760 case 84: return "R_PPC_GOT_TLSLD16_LO"; 761 case 85: return "R_PPC_GOT_TLSLD16_HI"; 762 case 86: return "R_PPC_GOT_TLSLD16_HA"; 763 case 87: return "R_PPC_GOT_TPREL16"; 764 case 88: return "R_PPC_GOT_TPREL16_LO"; 765 case 89: return "R_PPC_GOT_TPREL16_HI"; 766 case 90: return "R_PPC_GOT_TPREL16_HA"; 767 case 101: return "R_PPC_EMB_NADDR32"; 768 case 102: return "R_PPC_EMB_NADDR16"; 769 case 103: return "R_PPC_EMB_NADDR16_LO"; 770 case 104: return "R_PPC_EMB_NADDR16_HI"; 771 case 105: return "R_PPC_EMB_NADDR16_HA"; 772 case 106: return "R_PPC_EMB_SDAI16"; 773 case 107: return "R_PPC_EMB_SDA2I16"; 774 case 108: return "R_PPC_EMB_SDA2REL"; 775 case 109: return "R_PPC_EMB_SDA21"; 776 case 110: return "R_PPC_EMB_MRKREF"; 777 case 111: return "R_PPC_EMB_RELSEC16"; 778 case 112: return "R_PPC_EMB_RELST_LO"; 779 case 113: return "R_PPC_EMB_RELST_HI"; 780 case 114: return "R_PPC_EMB_RELST_HA"; 781 case 115: return "R_PPC_EMB_BIT_FLD"; 782 case 116: return "R_PPC_EMB_RELSDA"; 783 default: return ""; 784 } 785 case EM_SPARC: 786 case EM_SPARCV9: 787 switch(type) { 788 case 0: return "R_SPARC_NONE"; 789 case 1: return "R_SPARC_8"; 790 case 2: return "R_SPARC_16"; 791 case 3: return "R_SPARC_32"; 792 case 4: return "R_SPARC_DISP8"; 793 case 5: return "R_SPARC_DISP16"; 794 case 6: return "R_SPARC_DISP32"; 795 case 7: return "R_SPARC_WDISP30"; 796 case 8: return "R_SPARC_WDISP22"; 797 case 9: return "R_SPARC_HI22"; 798 case 10: return "R_SPARC_22"; 799 case 11: return "R_SPARC_13"; 800 case 12: return "R_SPARC_LO10"; 801 case 13: return "R_SPARC_GOT10"; 802 case 14: return "R_SPARC_GOT13"; 803 case 15: return "R_SPARC_GOT22"; 804 case 16: return "R_SPARC_PC10"; 805 case 17: return "R_SPARC_PC22"; 806 case 18: return "R_SPARC_WPLT30"; 807 case 19: return "R_SPARC_COPY"; 808 case 20: return "R_SPARC_GLOB_DAT"; 809 case 21: return "R_SPARC_JMP_SLOT"; 810 case 22: return "R_SPARC_RELATIVE"; 811 case 23: return "R_SPARC_UA32"; 812 case 24: return "R_SPARC_PLT32"; 813 case 25: return "R_SPARC_HIPLT22"; 814 case 26: return "R_SPARC_LOPLT10"; 815 case 27: return "R_SPARC_PCPLT32"; 816 case 28: return "R_SPARC_PCPLT22"; 817 case 29: return "R_SPARC_PCPLT10"; 818 case 30: return "R_SPARC_10"; 819 case 31: return "R_SPARC_11"; 820 case 32: return "R_SPARC_64"; 821 case 33: return "R_SPARC_OLO10"; 822 case 34: return "R_SPARC_HH22"; 823 case 35: return "R_SPARC_HM10"; 824 case 36: return "R_SPARC_LM22"; 825 case 37: return "R_SPARC_PC_HH22"; 826 case 38: return "R_SPARC_PC_HM10"; 827 case 39: return "R_SPARC_PC_LM22"; 828 case 40: return "R_SPARC_WDISP16"; 829 case 41: return "R_SPARC_WDISP19"; 830 case 42: return "R_SPARC_GLOB_JMP"; 831 case 43: return "R_SPARC_7"; 832 case 44: return "R_SPARC_5"; 833 case 45: return "R_SPARC_6"; 834 case 46: return "R_SPARC_DISP64"; 835 case 47: return "R_SPARC_PLT64"; 836 case 48: return "R_SPARC_HIX22"; 837 case 49: return "R_SPARC_LOX10"; 838 case 50: return "R_SPARC_H44"; 839 case 51: return "R_SPARC_M44"; 840 case 52: return "R_SPARC_L44"; 841 case 53: return "R_SPARC_REGISTER"; 842 case 54: return "R_SPARC_UA64"; 843 case 55: return "R_SPARC_UA16"; 844 case 56: return "R_SPARC_TLS_GD_HI22"; 845 case 57: return "R_SPARC_TLS_GD_LO10"; 846 case 58: return "R_SPARC_TLS_GD_ADD"; 847 case 59: return "R_SPARC_TLS_GD_CALL"; 848 case 60: return "R_SPARC_TLS_LDM_HI22"; 849 case 61: return "R_SPARC_TLS_LDM_LO10"; 850 case 62: return "R_SPARC_TLS_LDM_ADD"; 851 case 63: return "R_SPARC_TLS_LDM_CALL"; 852 case 64: return "R_SPARC_TLS_LDO_HIX22"; 853 case 65: return "R_SPARC_TLS_LDO_LOX10"; 854 case 66: return "R_SPARC_TLS_LDO_ADD"; 855 case 67: return "R_SPARC_TLS_IE_HI22"; 856 case 68: return "R_SPARC_TLS_IE_LO10"; 857 case 69: return "R_SPARC_TLS_IE_LD"; 858 case 70: return "R_SPARC_TLS_IE_LDX"; 859 case 71: return "R_SPARC_TLS_IE_ADD"; 860 case 72: return "R_SPARC_TLS_LE_HIX22"; 861 case 73: return "R_SPARC_TLS_LE_LOX10"; 862 case 74: return "R_SPARC_TLS_DTPMOD32"; 863 case 75: return "R_SPARC_TLS_DTPMOD64"; 864 case 76: return "R_SPARC_TLS_DTPOFF32"; 865 case 77: return "R_SPARC_TLS_DTPOFF64"; 866 case 78: return "R_SPARC_TLS_TPOFF32"; 867 case 79: return "R_SPARC_TLS_TPOFF64"; 868 default: return ""; 869 } 870 case EM_X86_64: 871 switch(type) { 872 case 0: return "R_X86_64_NONE"; 873 case 1: return "R_X86_64_64"; 874 case 2: return "R_X86_64_PC32"; 875 case 3: return "R_X86_64_GOT32"; 876 case 4: return "R_X86_64_PLT32"; 877 case 5: return "R_X86_64_COPY"; 878 case 6: return "R_X86_64_GLOB_DAT"; 879 case 7: return "R_X86_64_JUMP_SLOT"; 880 case 8: return "R_X86_64_RELATIVE"; 881 case 9: return "R_X86_64_GOTPCREL"; 882 case 10: return "R_X86_64_32"; 883 case 11: return "R_X86_64_32S"; 884 case 12: return "R_X86_64_16"; 885 case 13: return "R_X86_64_PC16"; 886 case 14: return "R_X86_64_8"; 887 case 15: return "R_X86_64_PC8"; 888 case 16: return "R_X86_64_DTPMOD64"; 889 case 17: return "R_X86_64_DTPOFF64"; 890 case 18: return "R_X86_64_TPOFF64"; 891 case 19: return "R_X86_64_TLSGD"; 892 case 20: return "R_X86_64_TLSLD"; 893 case 21: return "R_X86_64_DTPOFF32"; 894 case 22: return "R_X86_64_GOTTPOFF"; 895 case 23: return "R_X86_64_TPOFF32"; 896 default: return ""; 897 } 898 default: return ""; 899 } 900} 901 | |
902static void add_name(struct elfdump *ed, const char *name); 903static void elf_print_object(struct elfdump *ed); 904static void elf_print_elf(struct elfdump *ed); 905static void elf_print_ehdr(struct elfdump *ed); 906static void elf_print_phdr(struct elfdump *ed); 907static void elf_print_shdr(struct elfdump *ed); 908static void elf_print_symtab(struct elfdump *ed, int i); 909static void elf_print_symtabs(struct elfdump *ed); --- 16 unchanged lines hidden (view full) --- 926static void elf_print_svr4_hash64(struct elfdump *ed, struct section *s); 927static void elf_print_gnu_hash(struct elfdump *ed, struct section *s); 928static void elf_print_hash(struct elfdump *ed); 929static void elf_print_checksum(struct elfdump *ed); 930static void find_gotrel(struct elfdump *ed, struct section *gs, 931 struct rel_entry *got); 932static struct spec_name *find_name(struct elfdump *ed, const char *name); 933static int get_ent_count(const struct section *s, int *ent_count); | 587static void add_name(struct elfdump *ed, const char *name); 588static void elf_print_object(struct elfdump *ed); 589static void elf_print_elf(struct elfdump *ed); 590static void elf_print_ehdr(struct elfdump *ed); 591static void elf_print_phdr(struct elfdump *ed); 592static void elf_print_shdr(struct elfdump *ed); 593static void elf_print_symtab(struct elfdump *ed, int i); 594static void elf_print_symtabs(struct elfdump *ed); --- 16 unchanged lines hidden (view full) --- 611static void elf_print_svr4_hash64(struct elfdump *ed, struct section *s); 612static void elf_print_gnu_hash(struct elfdump *ed, struct section *s); 613static void elf_print_hash(struct elfdump *ed); 614static void elf_print_checksum(struct elfdump *ed); 615static void find_gotrel(struct elfdump *ed, struct section *gs, 616 struct rel_entry *got); 617static struct spec_name *find_name(struct elfdump *ed, const char *name); 618static int get_ent_count(const struct section *s, int *ent_count); |
934static const char *get_symbol_name(struct elfdump *ed, int symtab, int i); | 619static const char *get_symbol_name(struct elfdump *ed, uint32_t symtab, int i); |
935static const char *get_string(struct elfdump *ed, int strtab, size_t off); 936static void get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs); 937static void load_sections(struct elfdump *ed); 938static void unload_sections(struct elfdump *ed); 939static void usage(void); 940#ifdef USE_LIBARCHIVE_AR 941static int ac_detect_ar(int fd); 942static void ac_print_ar(struct elfdump *ed, int fd); --- 162 unchanged lines hidden (view full) --- 1105{ 1106 struct archive *a; 1107 struct archive_entry *entry; 1108 struct arsym_entry *arsym; 1109 const char *name; 1110 char idx[10], *b; 1111 void *buff; 1112 size_t size; | 620static const char *get_string(struct elfdump *ed, int strtab, size_t off); 621static void get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs); 622static void load_sections(struct elfdump *ed); 623static void unload_sections(struct elfdump *ed); 624static void usage(void); 625#ifdef USE_LIBARCHIVE_AR 626static int ac_detect_ar(int fd); 627static void ac_print_ar(struct elfdump *ed, int fd); --- 162 unchanged lines hidden (view full) --- 790{ 791 struct archive *a; 792 struct archive_entry *entry; 793 struct arsym_entry *arsym; 794 const char *name; 795 char idx[10], *b; 796 void *buff; 797 size_t size; |
1113 uint32_t cnt; 1114 int i, r; | 798 uint32_t cnt, i; 799 int r; |
1115 1116 if (lseek(fd, 0, SEEK_SET) == -1) 1117 err(EXIT_FAILURE, "lseek failed"); 1118 if ((a = archive_read_new()) == NULL) 1119 errx(EXIT_FAILURE, "%s", archive_error_string(a)); 1120 archive_read_support_format_ar(a); 1121 AC(archive_read_open_fd(a, fd, 10240)); 1122 for(;;) { --- 32 unchanged lines hidden (view full) --- 1155 if (cnt == 0) { 1156 free(buff); 1157 continue; 1158 } 1159 arsym = calloc(cnt, sizeof(*arsym)); 1160 if (arsym == NULL) 1161 err(EXIT_FAILURE, "calloc failed"); 1162 b += sizeof(uint32_t); | 800 801 if (lseek(fd, 0, SEEK_SET) == -1) 802 err(EXIT_FAILURE, "lseek failed"); 803 if ((a = archive_read_new()) == NULL) 804 errx(EXIT_FAILURE, "%s", archive_error_string(a)); 805 archive_read_support_format_ar(a); 806 AC(archive_read_open_fd(a, fd, 10240)); 807 for(;;) { --- 32 unchanged lines hidden (view full) --- 840 if (cnt == 0) { 841 free(buff); 842 continue; 843 } 844 arsym = calloc(cnt, sizeof(*arsym)); 845 if (arsym == NULL) 846 err(EXIT_FAILURE, "calloc failed"); 847 b += sizeof(uint32_t); |
1163 for (i = 0; (size_t)i < cnt; i++) { | 848 for (i = 0; i < cnt; i++) { |
1164 arsym[i].off = be32dec(b); 1165 b += sizeof(uint32_t); 1166 } | 849 arsym[i].off = be32dec(b); 850 b += sizeof(uint32_t); 851 } |
1167 for (i = 0; (size_t)i < cnt; i++) { | 852 for (i = 0; i < cnt; i++) { |
1168 arsym[i].sym_name = b; 1169 b += strlen(b) + 1; 1170 } 1171 if (ed->flags & SOLARIS_FMT) { 1172 PRT("\nSymbol Table: (archive)\n"); 1173 PRT(" index offset symbol\n"); 1174 } else 1175 PRT("\nsymbol table (archive):\n"); | 853 arsym[i].sym_name = b; 854 b += strlen(b) + 1; 855 } 856 if (ed->flags & SOLARIS_FMT) { 857 PRT("\nSymbol Table: (archive)\n"); 858 PRT(" index offset symbol\n"); 859 } else 860 PRT("\nsymbol table (archive):\n"); |
1176 for (i = 0; (size_t)i < cnt; i++) { | 861 for (i = 0; i < cnt; i++) { |
1177 if (ed->flags & SOLARIS_FMT) { 1178 snprintf(idx, sizeof(idx), "[%d]", i); 1179 PRT("%10s ", idx); 1180 PRT("0x%8.8jx ", 1181 (uintmax_t)arsym[i].off); 1182 PRT("%s\n", arsym[i].sym_name); 1183 } else { 1184 PRT("\nentry: %d\n", i); --- 39 unchanged lines hidden (view full) --- 1224static void 1225elf_print_ar(struct elfdump *ed, int fd) 1226{ 1227 Elf *e; 1228 Elf_Arhdr *arh; 1229 Elf_Arsym *arsym; 1230 Elf_Cmd cmd; 1231 char idx[10]; | 862 if (ed->flags & SOLARIS_FMT) { 863 snprintf(idx, sizeof(idx), "[%d]", i); 864 PRT("%10s ", idx); 865 PRT("0x%8.8jx ", 866 (uintmax_t)arsym[i].off); 867 PRT("%s\n", arsym[i].sym_name); 868 } else { 869 PRT("\nentry: %d\n", i); --- 39 unchanged lines hidden (view full) --- 909static void 910elf_print_ar(struct elfdump *ed, int fd) 911{ 912 Elf *e; 913 Elf_Arhdr *arh; 914 Elf_Arsym *arsym; 915 Elf_Cmd cmd; 916 char idx[10]; |
1232 size_t cnt; 1233 int i; | 917 size_t cnt, i; |
1234 1235 ed->ar = ed->elf; 1236 1237 if (ed->flags & PRINT_ARSYM) { 1238 cnt = 0; 1239 if ((arsym = elf_getarsym(ed->ar, &cnt)) == NULL) { 1240 warnx("elf_getarsym failed: %s", elf_errmsg(-1)); 1241 goto print_members; 1242 } 1243 if (cnt == 0) 1244 goto print_members; 1245 if (ed->flags & SOLARIS_FMT) { 1246 PRT("\nSymbol Table: (archive)\n"); 1247 PRT(" index offset member name and symbol\n"); 1248 } else 1249 PRT("\nsymbol table (archive):\n"); | 918 919 ed->ar = ed->elf; 920 921 if (ed->flags & PRINT_ARSYM) { 922 cnt = 0; 923 if ((arsym = elf_getarsym(ed->ar, &cnt)) == NULL) { 924 warnx("elf_getarsym failed: %s", elf_errmsg(-1)); 925 goto print_members; 926 } 927 if (cnt == 0) 928 goto print_members; 929 if (ed->flags & SOLARIS_FMT) { 930 PRT("\nSymbol Table: (archive)\n"); 931 PRT(" index offset member name and symbol\n"); 932 } else 933 PRT("\nsymbol table (archive):\n"); |
1250 for (i = 0; (size_t)i < cnt - 1; i++) { | 934 for (i = 0; i < cnt - 1; i++) { |
1251 if (elf_rand(ed->ar, arsym[i].as_off) != 1252 arsym[i].as_off) { 1253 warnx("elf_rand failed: %s", elf_errmsg(-1)); 1254 break; 1255 } 1256 if ((e = elf_begin(fd, ELF_C_READ, ed->ar)) == NULL) { 1257 warnx("elf_begin failed: %s", elf_errmsg(-1)); 1258 break; 1259 } 1260 if ((arh = elf_getarhdr(e)) == NULL) { 1261 warnx("elf_getarhdr failed: %s", 1262 elf_errmsg(-1)); 1263 break; 1264 } 1265 if (ed->flags & SOLARIS_FMT) { | 935 if (elf_rand(ed->ar, arsym[i].as_off) != 936 arsym[i].as_off) { 937 warnx("elf_rand failed: %s", elf_errmsg(-1)); 938 break; 939 } 940 if ((e = elf_begin(fd, ELF_C_READ, ed->ar)) == NULL) { 941 warnx("elf_begin failed: %s", elf_errmsg(-1)); 942 break; 943 } 944 if ((arh = elf_getarhdr(e)) == NULL) { 945 warnx("elf_getarhdr failed: %s", 946 elf_errmsg(-1)); 947 break; 948 } 949 if (ed->flags & SOLARIS_FMT) { |
1266 snprintf(idx, sizeof(idx), "[%d]", i); | 950 snprintf(idx, sizeof(idx), "[%zu]", i); |
1267 PRT("%10s ", idx); 1268 PRT("0x%8.8jx ", 1269 (uintmax_t)arsym[i].as_off); 1270 PRT("(%s):%s\n", arh->ar_name, 1271 arsym[i].as_name); 1272 } else { | 951 PRT("%10s ", idx); 952 PRT("0x%8.8jx ", 953 (uintmax_t)arsym[i].as_off); 954 PRT("(%s):%s\n", arh->ar_name, 955 arsym[i].as_name); 956 } else { |
1273 PRT("\nentry: %d\n", i); | 957 PRT("\nentry: %zu\n", i); |
1274 PRT("\toffset: %#jx\n", 1275 (uintmax_t)arsym[i].as_off); 1276 PRT("\tmember: %s\n", arh->ar_name); 1277 PRT("\tsymbol: %s\n", arsym[i].as_name); 1278 } 1279 elf_end(e); 1280 } 1281 --- 244 unchanged lines hidden (view full) --- 1526 return (NULL); 1527} 1528 1529/* 1530 * Retrieve the name of a symbol using the section index of the symbol 1531 * table and the index of the symbol within that table. 1532 */ 1533static const char * | 958 PRT("\toffset: %#jx\n", 959 (uintmax_t)arsym[i].as_off); 960 PRT("\tmember: %s\n", arh->ar_name); 961 PRT("\tsymbol: %s\n", arsym[i].as_name); 962 } 963 elf_end(e); 964 } 965 --- 244 unchanged lines hidden (view full) --- 1210 return (NULL); 1211} 1212 1213/* 1214 * Retrieve the name of a symbol using the section index of the symbol 1215 * table and the index of the symbol within that table. 1216 */ 1217static const char * |
1534get_symbol_name(struct elfdump *ed, int symtab, int i) | 1218get_symbol_name(struct elfdump *ed, uint32_t symtab, int i) |
1535{ 1536 static char sname[64]; 1537 struct section *s; 1538 const char *name; 1539 GElf_Sym sym; 1540 Elf_Data *data; 1541 int elferr; 1542 | 1219{ 1220 static char sname[64]; 1221 struct section *s; 1222 const char *name; 1223 GElf_Sym sym; 1224 Elf_Data *data; 1225 int elferr; 1226 |
1227 if (symtab >= ed->shnum) 1228 return (""); |
|
1543 s = &ed->sl[symtab]; 1544 if (s->type != SHT_SYMTAB && s->type != SHT_DYNSYM) 1545 return (""); 1546 (void) elf_errno(); 1547 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1548 elferr = elf_errno(); 1549 if (elferr != 0) 1550 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); --- 40 unchanged lines hidden (view full) --- 1591 return; 1592 1593 if (ed->flags & SOLARIS_FMT) { 1594 PRT("\nELF Header\n"); 1595 PRT(" ei_magic: { %#x, %c, %c, %c }\n", 1596 ed->ehdr.e_ident[0], ed->ehdr.e_ident[1], 1597 ed->ehdr.e_ident[2], ed->ehdr.e_ident[3]); 1598 PRT(" ei_class: %-18s", | 1229 s = &ed->sl[symtab]; 1230 if (s->type != SHT_SYMTAB && s->type != SHT_DYNSYM) 1231 return (""); 1232 (void) elf_errno(); 1233 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1234 elferr = elf_errno(); 1235 if (elferr != 0) 1236 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); --- 40 unchanged lines hidden (view full) --- 1277 return; 1278 1279 if (ed->flags & SOLARIS_FMT) { 1280 PRT("\nELF Header\n"); 1281 PRT(" ei_magic: { %#x, %c, %c, %c }\n", 1282 ed->ehdr.e_ident[0], ed->ehdr.e_ident[1], 1283 ed->ehdr.e_ident[2], ed->ehdr.e_ident[3]); 1284 PRT(" ei_class: %-18s", |
1599 ei_classes[ed->ehdr.e_ident[EI_CLASS]]); 1600 PRT(" ei_data: %s\n", ei_data[ed->ehdr.e_ident[EI_DATA]]); | 1285 elf_class_str(ed->ehdr.e_ident[EI_CLASS])); 1286 PRT(" ei_data: %s\n", 1287 elf_data_str(ed->ehdr.e_ident[EI_DATA])); |
1601 PRT(" e_machine: %-18s", e_machines(ed->ehdr.e_machine)); | 1288 PRT(" e_machine: %-18s", e_machines(ed->ehdr.e_machine)); |
1602 PRT(" e_version: %s\n", ei_versions[ed->ehdr.e_version]); 1603 PRT(" e_type: %s\n", e_types[ed->ehdr.e_type]); | 1289 PRT(" e_version: %s\n", 1290 elf_version_str(ed->ehdr.e_version)); 1291 PRT(" e_type: %s\n", elf_type_str(ed->ehdr.e_type)); |
1604 PRT(" e_flags: %18d\n", ed->ehdr.e_flags); 1605 PRT(" e_entry: %#18jx", (uintmax_t)ed->ehdr.e_entry); 1606 PRT(" e_ehsize: %6d", ed->ehdr.e_ehsize); 1607 PRT(" e_shstrndx:%5d\n", ed->ehdr.e_shstrndx); 1608 PRT(" e_shoff: %#18jx", (uintmax_t)ed->ehdr.e_shoff); 1609 PRT(" e_shentsize: %3d", ed->ehdr.e_shentsize); 1610 PRT(" e_shnum: %5d\n", ed->ehdr.e_shnum); 1611 PRT(" e_phoff: %#18jx", (uintmax_t)ed->ehdr.e_phoff); 1612 PRT(" e_phentsize: %3d", ed->ehdr.e_phentsize); 1613 PRT(" e_phnum: %5d\n", ed->ehdr.e_phnum); 1614 } else { 1615 PRT("\nelf header:\n"); 1616 PRT("\n"); 1617 PRT("\te_ident: %s %s %s\n", | 1292 PRT(" e_flags: %18d\n", ed->ehdr.e_flags); 1293 PRT(" e_entry: %#18jx", (uintmax_t)ed->ehdr.e_entry); 1294 PRT(" e_ehsize: %6d", ed->ehdr.e_ehsize); 1295 PRT(" e_shstrndx:%5d\n", ed->ehdr.e_shstrndx); 1296 PRT(" e_shoff: %#18jx", (uintmax_t)ed->ehdr.e_shoff); 1297 PRT(" e_shentsize: %3d", ed->ehdr.e_shentsize); 1298 PRT(" e_shnum: %5d\n", ed->ehdr.e_shnum); 1299 PRT(" e_phoff: %#18jx", (uintmax_t)ed->ehdr.e_phoff); 1300 PRT(" e_phentsize: %3d", ed->ehdr.e_phentsize); 1301 PRT(" e_phnum: %5d\n", ed->ehdr.e_phnum); 1302 } else { 1303 PRT("\nelf header:\n"); 1304 PRT("\n"); 1305 PRT("\te_ident: %s %s %s\n", |
1618 ei_classes[ed->ehdr.e_ident[EI_CLASS]], 1619 ei_data[ed->ehdr.e_ident[EI_DATA]], | 1306 elf_class_str(ed->ehdr.e_ident[EI_CLASS]), 1307 elf_data_str(ed->ehdr.e_ident[EI_DATA]), |
1620 ei_abis[ed->ehdr.e_ident[EI_OSABI]]); | 1308 ei_abis[ed->ehdr.e_ident[EI_OSABI]]); |
1621 PRT("\te_type: %s\n", e_types[ed->ehdr.e_type]); | 1309 PRT("\te_type: %s\n", elf_type_str(ed->ehdr.e_type)); |
1622 PRT("\te_machine: %s\n", e_machines(ed->ehdr.e_machine)); | 1310 PRT("\te_machine: %s\n", e_machines(ed->ehdr.e_machine)); |
1623 PRT("\te_version: %s\n", ei_versions[ed->ehdr.e_version]); | 1311 PRT("\te_version: %s\n", elf_version_str(ed->ehdr.e_version)); |
1624 PRT("\te_entry: %#jx\n", (uintmax_t)ed->ehdr.e_entry); 1625 PRT("\te_phoff: %ju\n", (uintmax_t)ed->ehdr.e_phoff); 1626 PRT("\te_shoff: %ju\n", (uintmax_t) ed->ehdr.e_shoff); 1627 PRT("\te_flags: %u\n", ed->ehdr.e_flags); 1628 PRT("\te_ehsize: %u\n", ed->ehdr.e_ehsize); 1629 PRT("\te_phentsize: %u\n", ed->ehdr.e_phentsize); 1630 PRT("\te_phnum: %u\n", ed->ehdr.e_phnum); 1631 PRT("\te_shentsize: %u\n", ed->ehdr.e_shentsize); --- 4 unchanged lines hidden (view full) --- 1636 1637/* 1638 * Dump the ELF Program Header Table. 1639 */ 1640static void 1641elf_print_phdr(struct elfdump *ed) 1642{ 1643 GElf_Phdr ph; | 1312 PRT("\te_entry: %#jx\n", (uintmax_t)ed->ehdr.e_entry); 1313 PRT("\te_phoff: %ju\n", (uintmax_t)ed->ehdr.e_phoff); 1314 PRT("\te_shoff: %ju\n", (uintmax_t) ed->ehdr.e_shoff); 1315 PRT("\te_flags: %u\n", ed->ehdr.e_flags); 1316 PRT("\te_ehsize: %u\n", ed->ehdr.e_ehsize); 1317 PRT("\te_phentsize: %u\n", ed->ehdr.e_phentsize); 1318 PRT("\te_phnum: %u\n", ed->ehdr.e_phnum); 1319 PRT("\te_shentsize: %u\n", ed->ehdr.e_shentsize); --- 4 unchanged lines hidden (view full) --- 1324 1325/* 1326 * Dump the ELF Program Header Table. 1327 */ 1328static void 1329elf_print_phdr(struct elfdump *ed) 1330{ 1331 GElf_Phdr ph; |
1644 size_t phnum; 1645 int header, i; | 1332 size_t phnum, i; 1333 int header; |
1646 1647 if (elf_getphnum(ed->elf, &phnum) == 0) { 1648 warnx("elf_getphnum failed: %s", elf_errmsg(-1)); 1649 return; 1650 } 1651 header = 0; | 1334 1335 if (elf_getphnum(ed->elf, &phnum) == 0) { 1336 warnx("elf_getphnum failed: %s", elf_errmsg(-1)); 1337 return; 1338 } 1339 header = 0; |
1652 for (i = 0; (u_int64_t) i < phnum; i++) { | 1340 for (i = 0; i < phnum; i++) { |
1653 if (gelf_getphdr(ed->elf, i, &ph) != &ph) { 1654 warnx("elf_getphdr failed: %s", elf_errmsg(-1)); 1655 continue; 1656 } 1657 if (!STAILQ_EMPTY(&ed->snl) && | 1341 if (gelf_getphdr(ed->elf, i, &ph) != &ph) { 1342 warnx("elf_getphdr failed: %s", elf_errmsg(-1)); 1343 continue; 1344 } 1345 if (!STAILQ_EMPTY(&ed->snl) && |
1658 find_name(ed, p_types[ph.p_type & 0x7]) == NULL) | 1346 find_name(ed, elf_phdr_type_str(ph.p_type)) == NULL) |
1659 continue; 1660 if (ed->flags & SOLARIS_FMT) { | 1347 continue; 1348 if (ed->flags & SOLARIS_FMT) { |
1661 PRT("\nProgram Header[%d]:\n", i); | 1349 PRT("\nProgram Header[%zu]:\n", i); |
1662 PRT(" p_vaddr: %#-14jx", (uintmax_t)ph.p_vaddr); | 1350 PRT(" p_vaddr: %#-14jx", (uintmax_t)ph.p_vaddr); |
1663 PRT(" p_flags: [ %s ]\n", p_flags[ph.p_flags]); | 1351 PRT(" p_flags: [ %s ]\n", 1352 p_flags[ph.p_flags & 0x7]); |
1664 PRT(" p_paddr: %#-14jx", (uintmax_t)ph.p_paddr); | 1353 PRT(" p_paddr: %#-14jx", (uintmax_t)ph.p_paddr); |
1665 PRT(" p_type: [ %s ]\n", p_types[ph.p_type & 0x7]); | 1354 PRT(" p_type: [ %s ]\n", 1355 elf_phdr_type_str(ph.p_type)); |
1666 PRT(" p_filesz: %#-14jx", 1667 (uintmax_t)ph.p_filesz); 1668 PRT(" p_memsz: %#jx\n", (uintmax_t)ph.p_memsz); 1669 PRT(" p_offset: %#-14jx", 1670 (uintmax_t)ph.p_offset); 1671 PRT(" p_align: %#jx\n", (uintmax_t)ph.p_align); 1672 } else { 1673 if (!header) { 1674 PRT("\nprogram header:\n"); 1675 header = 1; 1676 } 1677 PRT("\n"); | 1356 PRT(" p_filesz: %#-14jx", 1357 (uintmax_t)ph.p_filesz); 1358 PRT(" p_memsz: %#jx\n", (uintmax_t)ph.p_memsz); 1359 PRT(" p_offset: %#-14jx", 1360 (uintmax_t)ph.p_offset); 1361 PRT(" p_align: %#jx\n", (uintmax_t)ph.p_align); 1362 } else { 1363 if (!header) { 1364 PRT("\nprogram header:\n"); 1365 header = 1; 1366 } 1367 PRT("\n"); |
1678 PRT("entry: %d\n", i); 1679 PRT("\tp_type: %s\n", p_types[ph.p_type & 0x7]); | 1368 PRT("entry: %zu\n", i); 1369 PRT("\tp_type: %s\n", elf_phdr_type_str(ph.p_type)); |
1680 PRT("\tp_offset: %ju\n", (uintmax_t)ph.p_offset); 1681 PRT("\tp_vaddr: %#jx\n", (uintmax_t)ph.p_vaddr); 1682 PRT("\tp_paddr: %#jx\n", (uintmax_t)ph.p_paddr); 1683 PRT("\tp_filesz: %ju\n", (uintmax_t)ph.p_filesz); 1684 PRT("\tp_memsz: %ju\n", (uintmax_t)ph.p_memsz); | 1370 PRT("\tp_offset: %ju\n", (uintmax_t)ph.p_offset); 1371 PRT("\tp_vaddr: %#jx\n", (uintmax_t)ph.p_vaddr); 1372 PRT("\tp_paddr: %#jx\n", (uintmax_t)ph.p_paddr); 1373 PRT("\tp_filesz: %ju\n", (uintmax_t)ph.p_filesz); 1374 PRT("\tp_memsz: %ju\n", (uintmax_t)ph.p_memsz); |
1685 PRT("\tp_flags: %s\n", p_flags[ph.p_flags]); | 1375 PRT("\tp_flags: %s\n", p_flags[ph.p_flags & 0x7]); |
1686 PRT("\tp_align: %ju\n", (uintmax_t)ph.p_align); 1687 } 1688 } 1689} 1690 1691/* 1692 * Dump the ELF Section Header Table. 1693 */ 1694static void 1695elf_print_shdr(struct elfdump *ed) 1696{ 1697 struct section *s; | 1376 PRT("\tp_align: %ju\n", (uintmax_t)ph.p_align); 1377 } 1378 } 1379} 1380 1381/* 1382 * Dump the ELF Section Header Table. 1383 */ 1384static void 1385elf_print_shdr(struct elfdump *ed) 1386{ 1387 struct section *s; |
1698 int i; | 1388 size_t i; |
1699 1700 if (!STAILQ_EMPTY(&ed->snl)) 1701 return; 1702 1703 if ((ed->flags & SOLARIS_FMT) == 0) 1704 PRT("\nsection header:\n"); | 1389 1390 if (!STAILQ_EMPTY(&ed->snl)) 1391 return; 1392 1393 if ((ed->flags & SOLARIS_FMT) == 0) 1394 PRT("\nsection header:\n"); |
1705 for (i = 0; (size_t)i < ed->shnum; i++) { | 1395 for (i = 0; i < ed->shnum; i++) { |
1706 s = &ed->sl[i]; 1707 if (ed->flags & SOLARIS_FMT) { 1708 if (i == 0) 1709 continue; | 1396 s = &ed->sl[i]; 1397 if (ed->flags & SOLARIS_FMT) { 1398 if (i == 0) 1399 continue; |
1710 PRT("\nSection Header[%d]:", i); | 1400 PRT("\nSection Header[%zu]:", i); |
1711 PRT(" sh_name: %s\n", s->name); 1712 PRT(" sh_addr: %#-14jx", (uintmax_t)s->addr); 1713 if (s->flags != 0) 1714 PRT(" sh_flags: [ %s ]\n", sh_flags(s->flags)); 1715 else 1716 PRT(" sh_flags: 0\n"); 1717 PRT(" sh_size: %#-14jx", (uintmax_t)s->sz); 1718 PRT(" sh_type: [ %s ]\n", --- 43 unchanged lines hidden (view full) --- 1762 * Retrieve the content of the corresponding SHT_SUNW_versym section for 1763 * a symbol table section. 1764 */ 1765static void 1766get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs) 1767{ 1768 struct section *s; 1769 Elf_Data *data; | 1401 PRT(" sh_name: %s\n", s->name); 1402 PRT(" sh_addr: %#-14jx", (uintmax_t)s->addr); 1403 if (s->flags != 0) 1404 PRT(" sh_flags: [ %s ]\n", sh_flags(s->flags)); 1405 else 1406 PRT(" sh_flags: 0\n"); 1407 PRT(" sh_size: %#-14jx", (uintmax_t)s->sz); 1408 PRT(" sh_type: [ %s ]\n", --- 43 unchanged lines hidden (view full) --- 1452 * Retrieve the content of the corresponding SHT_SUNW_versym section for 1453 * a symbol table section. 1454 */ 1455static void 1456get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs) 1457{ 1458 struct section *s; 1459 Elf_Data *data; |
1770 int j, elferr; | 1460 size_t j; 1461 int elferr; |
1771 1772 s = NULL; | 1462 1463 s = NULL; |
1773 for (j = 0; (size_t)j < ed->shnum; j++) { | 1464 for (j = 0; j < ed->shnum; j++) { |
1774 s = &ed->sl[j]; 1775 if (s->type == SHT_SUNW_versym && s->link == (uint32_t)i) 1776 break; 1777 } | 1465 s = &ed->sl[j]; 1466 if (s->type == SHT_SUNW_versym && s->link == (uint32_t)i) 1467 break; 1468 } |
1778 if ((size_t)j >= ed->shnum) { | 1469 if (j >= ed->shnum) { |
1779 *vs = NULL; 1780 return; 1781 } 1782 (void) elf_errno(); 1783 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1784 elferr = elf_errno(); 1785 if (elferr != 0) 1786 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); --- 88 unchanged lines hidden (view full) --- 1875} 1876 1877/* 1878 * Dump the symbol tables. (.dynsym and .symtab) 1879 */ 1880static void 1881elf_print_symtabs(struct elfdump *ed) 1882{ | 1470 *vs = NULL; 1471 return; 1472 } 1473 (void) elf_errno(); 1474 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1475 elferr = elf_errno(); 1476 if (elferr != 0) 1477 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); --- 88 unchanged lines hidden (view full) --- 1566} 1567 1568/* 1569 * Dump the symbol tables. (.dynsym and .symtab) 1570 */ 1571static void 1572elf_print_symtabs(struct elfdump *ed) 1573{ |
1883 int i; | 1574 size_t i; |
1884 | 1575 |
1885 for (i = 0; (size_t)i < ed->shnum; i++) | 1576 for (i = 0; i < ed->shnum; i++) |
1886 if ((ed->sl[i].type == SHT_SYMTAB || 1887 ed->sl[i].type == SHT_DYNSYM) && 1888 (STAILQ_EMPTY(&ed->snl) || find_name(ed, ed->sl[i].name))) 1889 elf_print_symtab(ed, i); 1890} 1891 1892/* 1893 * Dump the content of .dynamic section. --- 46 unchanged lines hidden (view full) --- 1940 PRT("\n"); 1941 PRT("entry: %d\n", i); 1942 PRT("\td_tag: %s\n", d_tags(dyn.d_tag)); 1943 } 1944 switch(dyn.d_tag) { 1945 case DT_NEEDED: 1946 case DT_SONAME: 1947 case DT_RPATH: | 1577 if ((ed->sl[i].type == SHT_SYMTAB || 1578 ed->sl[i].type == SHT_DYNSYM) && 1579 (STAILQ_EMPTY(&ed->snl) || find_name(ed, ed->sl[i].name))) 1580 elf_print_symtab(ed, i); 1581} 1582 1583/* 1584 * Dump the content of .dynamic section. --- 46 unchanged lines hidden (view full) --- 1631 PRT("\n"); 1632 PRT("entry: %d\n", i); 1633 PRT("\td_tag: %s\n", d_tags(dyn.d_tag)); 1634 } 1635 switch(dyn.d_tag) { 1636 case DT_NEEDED: 1637 case DT_SONAME: 1638 case DT_RPATH: |
1639 case DT_RUNPATH: |
|
1948 if ((name = elf_strptr(ed->elf, s->link, 1949 dyn.d_un.d_val)) == NULL) 1950 name = ""; 1951 if (ed->flags & SOLARIS_FMT) 1952 PRT("%#-16jx %s\n", (uintmax_t)dyn.d_un.d_val, 1953 name); 1954 else 1955 PRT("\td_val: %s\n", name); --- 50 unchanged lines hidden (view full) --- 2006 * Dump a .rel/.rela section entry. 2007 */ 2008static void 2009elf_print_rel_entry(struct elfdump *ed, struct section *s, int j, 2010 struct rel_entry *r) 2011{ 2012 2013 if (ed->flags & SOLARIS_FMT) { | 1640 if ((name = elf_strptr(ed->elf, s->link, 1641 dyn.d_un.d_val)) == NULL) 1642 name = ""; 1643 if (ed->flags & SOLARIS_FMT) 1644 PRT("%#-16jx %s\n", (uintmax_t)dyn.d_un.d_val, 1645 name); 1646 else 1647 PRT("\td_val: %s\n", name); --- 50 unchanged lines hidden (view full) --- 1698 * Dump a .rel/.rela section entry. 1699 */ 1700static void 1701elf_print_rel_entry(struct elfdump *ed, struct section *s, int j, 1702 struct rel_entry *r) 1703{ 1704 1705 if (ed->flags & SOLARIS_FMT) { |
2014 PRT(" %-23s ", r_type(ed->ehdr.e_machine, | 1706 PRT(" %-23s ", elftc_reloc_type_str(ed->ehdr.e_machine, |
2015 GELF_R_TYPE(r->u_r.rel.r_info))); 2016 PRT("%#12jx ", (uintmax_t)r->u_r.rel.r_offset); 2017 if (r->type == SHT_RELA) 2018 PRT("%10jd ", (intmax_t)r->u_r.rela.r_addend); 2019 else 2020 PRT(" "); 2021 PRT("%-14s ", s->name); 2022 PRT("%s\n", r->symn); --- 77 unchanged lines hidden (view full) --- 2100/* 2101 * Dump relocation sections. 2102 */ 2103static void 2104elf_print_reloc(struct elfdump *ed) 2105{ 2106 struct section *s; 2107 Elf_Data *data; | 1707 GELF_R_TYPE(r->u_r.rel.r_info))); 1708 PRT("%#12jx ", (uintmax_t)r->u_r.rel.r_offset); 1709 if (r->type == SHT_RELA) 1710 PRT("%10jd ", (intmax_t)r->u_r.rela.r_addend); 1711 else 1712 PRT(" "); 1713 PRT("%-14s ", s->name); 1714 PRT("%s\n", r->symn); --- 77 unchanged lines hidden (view full) --- 1792/* 1793 * Dump relocation sections. 1794 */ 1795static void 1796elf_print_reloc(struct elfdump *ed) 1797{ 1798 struct section *s; 1799 Elf_Data *data; |
2108 int i, elferr; | 1800 size_t i; 1801 int elferr; |
2109 | 1802 |
2110 for (i = 0; (size_t)i < ed->shnum; i++) { | 1803 for (i = 0; i < ed->shnum; i++) { |
2111 s = &ed->sl[i]; 2112 if ((s->type == SHT_REL || s->type == SHT_RELA) && 2113 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { 2114 (void) elf_errno(); 2115 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 2116 elferr = elf_errno(); 2117 if (elferr != 0) 2118 warnx("elf_getdata failed: %s", --- 11 unchanged lines hidden (view full) --- 2130/* 2131 * Dump the content of PT_INTERP segment. 2132 */ 2133static void 2134elf_print_interp(struct elfdump *ed) 2135{ 2136 const char *s; 2137 GElf_Phdr phdr; | 1804 s = &ed->sl[i]; 1805 if ((s->type == SHT_REL || s->type == SHT_RELA) && 1806 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { 1807 (void) elf_errno(); 1808 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1809 elferr = elf_errno(); 1810 if (elferr != 0) 1811 warnx("elf_getdata failed: %s", --- 11 unchanged lines hidden (view full) --- 1823/* 1824 * Dump the content of PT_INTERP segment. 1825 */ 1826static void 1827elf_print_interp(struct elfdump *ed) 1828{ 1829 const char *s; 1830 GElf_Phdr phdr; |
2138 size_t phnum; 2139 int i; | 1831 size_t filesize, i, phnum; |
2140 2141 if (!STAILQ_EMPTY(&ed->snl) && find_name(ed, "PT_INTERP") == NULL) 2142 return; 2143 | 1832 1833 if (!STAILQ_EMPTY(&ed->snl) && find_name(ed, "PT_INTERP") == NULL) 1834 return; 1835 |
2144 if ((s = elf_rawfile(ed->elf, NULL)) == NULL) { | 1836 if ((s = elf_rawfile(ed->elf, &filesize)) == NULL) { |
2145 warnx("elf_rawfile failed: %s", elf_errmsg(-1)); 2146 return; 2147 } 2148 if (!elf_getphnum(ed->elf, &phnum)) { 2149 warnx("elf_getphnum failed: %s", elf_errmsg(-1)); 2150 return; 2151 } | 1837 warnx("elf_rawfile failed: %s", elf_errmsg(-1)); 1838 return; 1839 } 1840 if (!elf_getphnum(ed->elf, &phnum)) { 1841 warnx("elf_getphnum failed: %s", elf_errmsg(-1)); 1842 return; 1843 } |
2152 for (i = 0; (size_t)i < phnum; i++) { | 1844 for (i = 0; i < phnum; i++) { |
2153 if (gelf_getphdr(ed->elf, i, &phdr) != &phdr) { 2154 warnx("elf_getphdr failed: %s", elf_errmsg(-1)); 2155 continue; 2156 } 2157 if (phdr.p_type == PT_INTERP) { | 1845 if (gelf_getphdr(ed->elf, i, &phdr) != &phdr) { 1846 warnx("elf_getphdr failed: %s", elf_errmsg(-1)); 1847 continue; 1848 } 1849 if (phdr.p_type == PT_INTERP) { |
1850 if (phdr.p_offset >= filesize) { 1851 warnx("invalid phdr offset"); 1852 continue; 1853 } |
|
2158 PRT("\ninterp:\n"); 2159 PRT("\t%s\n", s + phdr.p_offset); 2160 } 2161 } 2162} 2163 2164/* | 1854 PRT("\ninterp:\n"); 1855 PRT("\t%s\n", s + phdr.p_offset); 1856 } 1857 } 1858} 1859 1860/* |
2165 * Search the relocation sections for entries refering to the .got section. | 1861 * Search the relocation sections for entries referring to the .got section. |
2166 */ 2167static void 2168find_gotrel(struct elfdump *ed, struct section *gs, struct rel_entry *got) 2169{ 2170 struct section *s; 2171 struct rel_entry r; 2172 Elf_Data *data; | 1862 */ 1863static void 1864find_gotrel(struct elfdump *ed, struct section *gs, struct rel_entry *got) 1865{ 1866 struct section *s; 1867 struct rel_entry r; 1868 Elf_Data *data; |
2173 int elferr, i, j, k, len; | 1869 size_t i; 1870 int elferr, j, k, len; |
2174 | 1871 |
2175 for(i = 0; (size_t)i < ed->shnum; i++) { | 1872 for(i = 0; i < ed->shnum; i++) { |
2176 s = &ed->sl[i]; 2177 if (s->type != SHT_REL && s->type != SHT_RELA) 2178 continue; 2179 (void) elf_errno(); 2180 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 2181 elferr = elf_errno(); 2182 if (elferr != 0) 2183 warnx("elf_getdata failed: %s", --- 60 unchanged lines hidden (view full) --- 2244 elferr = elf_errno(); 2245 if (elferr != 0) 2246 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 2247 return; 2248 } 2249 2250 /* 2251 * GOT section has section type SHT_PROGBITS, thus libelf treats it as | 1873 s = &ed->sl[i]; 1874 if (s->type != SHT_REL && s->type != SHT_RELA) 1875 continue; 1876 (void) elf_errno(); 1877 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1878 elferr = elf_errno(); 1879 if (elferr != 0) 1880 warnx("elf_getdata failed: %s", --- 60 unchanged lines hidden (view full) --- 1941 elferr = elf_errno(); 1942 if (elferr != 0) 1943 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 1944 return; 1945 } 1946 1947 /* 1948 * GOT section has section type SHT_PROGBITS, thus libelf treats it as |
2252 * byte stream and will not perfrom any translation on it. As a result, | 1949 * byte stream and will not perform any translation on it. As a result, |
2253 * an exlicit call to gelf_xlatetom is needed here. Depends on arch, 2254 * GOT section should be translated to either WORD or XWORD. 2255 */ 2256 if (ed->ec == ELFCLASS32) 2257 data->d_type = ELF_T_WORD; 2258 else 2259 data->d_type = ELF_T_XWORD; 2260 memcpy(&dst, data, sizeof(Elf_Data)); --- 26 unchanged lines hidden (view full) --- 2287 (uintmax_t) (s->addr + i * s->entsize)); 2288 PRT("%-8.8x ", *((uint32_t *)dst.d_buf + i)); 2289 } else { 2290 PRT("%-16.16jx ", 2291 (uintmax_t) (s->addr + i * s->entsize)); 2292 PRT("%-16.16jx ", 2293 (uintmax_t) *((uint64_t *)dst.d_buf + i)); 2294 } | 1950 * an exlicit call to gelf_xlatetom is needed here. Depends on arch, 1951 * GOT section should be translated to either WORD or XWORD. 1952 */ 1953 if (ed->ec == ELFCLASS32) 1954 data->d_type = ELF_T_WORD; 1955 else 1956 data->d_type = ELF_T_XWORD; 1957 memcpy(&dst, data, sizeof(Elf_Data)); --- 26 unchanged lines hidden (view full) --- 1984 (uintmax_t) (s->addr + i * s->entsize)); 1985 PRT("%-8.8x ", *((uint32_t *)dst.d_buf + i)); 1986 } else { 1987 PRT("%-16.16jx ", 1988 (uintmax_t) (s->addr + i * s->entsize)); 1989 PRT("%-16.16jx ", 1990 (uintmax_t) *((uint64_t *)dst.d_buf + i)); 1991 } |
2295 PRT("%-18s ", r_type(ed->ehdr.e_machine, | 1992 PRT("%-18s ", elftc_reloc_type_str(ed->ehdr.e_machine, |
2296 GELF_R_TYPE(got[i].u_r.rel.r_info))); 2297 if (ed->ec == ELFCLASS32) 2298 PRT("%-8.8jd ", 2299 (intmax_t)got[i].u_r.rela.r_addend); 2300 else 2301 PRT("%-12.12jd ", 2302 (intmax_t)got[i].u_r.rela.r_addend); 2303 if (got[i].symn == NULL) --- 15 unchanged lines hidden (view full) --- 2319 2320/* 2321 * Dump the content of Global Offset Table section. 2322 */ 2323static void 2324elf_print_got(struct elfdump *ed) 2325{ 2326 struct section *s; | 1993 GELF_R_TYPE(got[i].u_r.rel.r_info))); 1994 if (ed->ec == ELFCLASS32) 1995 PRT("%-8.8jd ", 1996 (intmax_t)got[i].u_r.rela.r_addend); 1997 else 1998 PRT("%-12.12jd ", 1999 (intmax_t)got[i].u_r.rela.r_addend); 2000 if (got[i].symn == NULL) --- 15 unchanged lines hidden (view full) --- 2016 2017/* 2018 * Dump the content of Global Offset Table section. 2019 */ 2020static void 2021elf_print_got(struct elfdump *ed) 2022{ 2023 struct section *s; |
2327 int i; | 2024 size_t i; |
2328 2329 if (!STAILQ_EMPTY(&ed->snl)) 2330 return; 2331 2332 s = NULL; | 2025 2026 if (!STAILQ_EMPTY(&ed->snl)) 2027 return; 2028 2029 s = NULL; |
2333 for (i = 0; (size_t)i < ed->shnum; i++) { | 2030 for (i = 0; i < ed->shnum; i++) { |
2334 s = &ed->sl[i]; 2335 if (s->name && !strncmp(s->name, ".got", 4) && 2336 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) 2337 elf_print_got_section(ed, s); 2338 } 2339} 2340 2341/* --- 5 unchanged lines hidden (view full) --- 2347 struct section *s; 2348 Elf_Data *data; 2349 Elf_Note *en; 2350 uint32_t namesz; 2351 uint32_t descsz; 2352 uint32_t desc; 2353 size_t count; 2354 int elferr, i; | 2031 s = &ed->sl[i]; 2032 if (s->name && !strncmp(s->name, ".got", 4) && 2033 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) 2034 elf_print_got_section(ed, s); 2035 } 2036} 2037 2038/* --- 5 unchanged lines hidden (view full) --- 2044 struct section *s; 2045 Elf_Data *data; 2046 Elf_Note *en; 2047 uint32_t namesz; 2048 uint32_t descsz; 2049 uint32_t desc; 2050 size_t count; 2051 int elferr, i; |
2355 char *src, idx[10]; | 2052 uint8_t *src; 2053 char idx[10]; |
2356 2357 s = NULL; 2358 for (i = 0; (size_t)i < ed->shnum; i++) { 2359 s = &ed->sl[i]; 2360 if (s->type == SHT_NOTE && s->name && 2361 !strcmp(s->name, ".note.ABI-tag") && 2362 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) 2363 break; --- 14 unchanged lines hidden (view full) --- 2378 src = data->d_buf; 2379 count = data->d_size; 2380 while (count > sizeof(Elf_Note)) { 2381 en = (Elf_Note *) (uintptr_t) src; 2382 namesz = en->n_namesz; 2383 descsz = en->n_descsz; 2384 src += sizeof(Elf_Note); 2385 count -= sizeof(Elf_Note); | 2054 2055 s = NULL; 2056 for (i = 0; (size_t)i < ed->shnum; i++) { 2057 s = &ed->sl[i]; 2058 if (s->type == SHT_NOTE && s->name && 2059 !strcmp(s->name, ".note.ABI-tag") && 2060 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) 2061 break; --- 14 unchanged lines hidden (view full) --- 2076 src = data->d_buf; 2077 count = data->d_size; 2078 while (count > sizeof(Elf_Note)) { 2079 en = (Elf_Note *) (uintptr_t) src; 2080 namesz = en->n_namesz; 2081 descsz = en->n_descsz; 2082 src += sizeof(Elf_Note); 2083 count -= sizeof(Elf_Note); |
2084 if (roundup2(namesz, 4) + roundup2(descsz, 4) > count) { 2085 warnx("truncated note section"); 2086 return; 2087 } |
|
2386 if (ed->flags & SOLARIS_FMT) { 2387 PRT("\n type %#x\n", en->n_type); 2388 PRT(" namesz %#x:\n", en->n_namesz); 2389 PRT("%s\n", src); 2390 } else 2391 PRT("\t%s ", src); 2392 src += roundup2(namesz, 4); 2393 count -= roundup2(namesz, 4); --- 34 unchanged lines hidden (view full) --- 2428static void 2429elf_print_svr4_hash(struct elfdump *ed, struct section *s) 2430{ 2431 Elf_Data *data; 2432 uint32_t *buf; 2433 uint32_t *bucket, *chain; 2434 uint32_t nbucket, nchain; 2435 uint32_t *bl, *c, maxl, total; | 2088 if (ed->flags & SOLARIS_FMT) { 2089 PRT("\n type %#x\n", en->n_type); 2090 PRT(" namesz %#x:\n", en->n_namesz); 2091 PRT("%s\n", src); 2092 } else 2093 PRT("\t%s ", src); 2094 src += roundup2(namesz, 4); 2095 count -= roundup2(namesz, 4); --- 34 unchanged lines hidden (view full) --- 2130static void 2131elf_print_svr4_hash(struct elfdump *ed, struct section *s) 2132{ 2133 Elf_Data *data; 2134 uint32_t *buf; 2135 uint32_t *bucket, *chain; 2136 uint32_t nbucket, nchain; 2137 uint32_t *bl, *c, maxl, total; |
2436 int i, j, first, elferr; | 2138 uint32_t i, j; 2139 int first, elferr; |
2437 char idx[10]; 2438 2439 if (ed->flags & SOLARIS_FMT) 2440 PRT("\nHash Section: %s\n", s->name); 2441 else 2442 PRT("\nhash table (%s):\n", s->name); 2443 (void) elf_errno(); 2444 if ((data = elf_getdata(s->scn, NULL)) == NULL) { --- 9 unchanged lines hidden (view full) --- 2454 } 2455 buf = data->d_buf; 2456 nbucket = buf[0]; 2457 nchain = buf[1]; 2458 if (nbucket <= 0 || nchain <= 0) { 2459 warnx("Malformed .hash section"); 2460 return; 2461 } | 2140 char idx[10]; 2141 2142 if (ed->flags & SOLARIS_FMT) 2143 PRT("\nHash Section: %s\n", s->name); 2144 else 2145 PRT("\nhash table (%s):\n", s->name); 2146 (void) elf_errno(); 2147 if ((data = elf_getdata(s->scn, NULL)) == NULL) { --- 9 unchanged lines hidden (view full) --- 2157 } 2158 buf = data->d_buf; 2159 nbucket = buf[0]; 2160 nchain = buf[1]; 2161 if (nbucket <= 0 || nchain <= 0) { 2162 warnx("Malformed .hash section"); 2163 return; 2164 } |
2462 if (data->d_size != (nbucket + nchain + 2) * sizeof(uint32_t)) { | 2165 if (data->d_size != 2166 ((uint64_t)nbucket + (uint64_t)nchain + 2) * sizeof(uint32_t)) { |
2463 warnx("Malformed .hash section"); 2464 return; 2465 } 2466 bucket = &buf[2]; 2467 chain = &buf[2 + nbucket]; 2468 2469 if (ed->flags & SOLARIS_FMT) { 2470 maxl = 0; 2471 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2472 err(EXIT_FAILURE, "calloc failed"); | 2167 warnx("Malformed .hash section"); 2168 return; 2169 } 2170 bucket = &buf[2]; 2171 chain = &buf[2 + nbucket]; 2172 2173 if (ed->flags & SOLARIS_FMT) { 2174 maxl = 0; 2175 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2176 err(EXIT_FAILURE, "calloc failed"); |
2473 for (i = 0; (uint32_t)i < nbucket; i++) 2474 for (j = bucket[i]; j > 0 && (uint32_t)j < nchain; 2475 j = chain[j]) | 2177 for (i = 0; i < nbucket; i++) 2178 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) |
2476 if (++bl[i] > maxl) 2477 maxl = bl[i]; 2478 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2479 err(EXIT_FAILURE, "calloc failed"); | 2179 if (++bl[i] > maxl) 2180 maxl = bl[i]; 2181 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2182 err(EXIT_FAILURE, "calloc failed"); |
2480 for (i = 0; (uint32_t)i < nbucket; i++) | 2183 for (i = 0; i < nbucket; i++) |
2481 c[bl[i]]++; 2482 PRT(" bucket symndx name\n"); | 2184 c[bl[i]]++; 2185 PRT(" bucket symndx name\n"); |
2483 for (i = 0; (uint32_t)i < nbucket; i++) { | 2186 for (i = 0; i < nbucket; i++) { |
2484 first = 1; | 2187 first = 1; |
2485 for (j = bucket[i]; j > 0 && (uint32_t)j < nchain; 2486 j = chain[j]) { | 2188 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) { |
2487 if (first) { 2488 PRT("%10d ", i); 2489 first = 0; 2490 } else 2491 PRT(" "); 2492 snprintf(idx, sizeof(idx), "[%d]", j); 2493 PRT("%-10s ", idx); 2494 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2495 } 2496 } 2497 PRT("\n"); 2498 total = 0; | 2189 if (first) { 2190 PRT("%10d ", i); 2191 first = 0; 2192 } else 2193 PRT(" "); 2194 snprintf(idx, sizeof(idx), "[%d]", j); 2195 PRT("%-10s ", idx); 2196 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2197 } 2198 } 2199 PRT("\n"); 2200 total = 0; |
2499 for (i = 0; (uint32_t)i <= maxl; i++) { | 2201 for (i = 0; i <= maxl; i++) { |
2500 total += c[i] * i; 2501 PRT("%10u buckets contain %8d symbols\n", c[i], i); 2502 } 2503 PRT("%10u buckets %8u symbols (globals)\n", nbucket, 2504 total); 2505 } else { 2506 PRT("\nnbucket: %u\n", nbucket); 2507 PRT("nchain: %u\n\n", nchain); | 2202 total += c[i] * i; 2203 PRT("%10u buckets contain %8d symbols\n", c[i], i); 2204 } 2205 PRT("%10u buckets %8u symbols (globals)\n", nbucket, 2206 total); 2207 } else { 2208 PRT("\nnbucket: %u\n", nbucket); 2209 PRT("nchain: %u\n\n", nchain); |
2508 for (i = 0; (uint32_t)i < nbucket; i++) | 2210 for (i = 0; i < nbucket; i++) |
2509 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); | 2211 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); |
2510 for (i = 0; (uint32_t)i < nchain; i++) | 2212 for (i = 0; i < nchain; i++) |
2511 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); 2512 } 2513} 2514 2515/* 2516 * Dump a 64bit hash table. 2517 */ 2518static void 2519elf_print_svr4_hash64(struct elfdump *ed, struct section *s) 2520{ 2521 Elf_Data *data, dst; 2522 uint64_t *buf; 2523 uint64_t *bucket, *chain; 2524 uint64_t nbucket, nchain; 2525 uint64_t *bl, *c, maxl, total; | 2213 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); 2214 } 2215} 2216 2217/* 2218 * Dump a 64bit hash table. 2219 */ 2220static void 2221elf_print_svr4_hash64(struct elfdump *ed, struct section *s) 2222{ 2223 Elf_Data *data, dst; 2224 uint64_t *buf; 2225 uint64_t *bucket, *chain; 2226 uint64_t nbucket, nchain; 2227 uint64_t *bl, *c, maxl, total; |
2526 int i, j, elferr, first; | 2228 uint64_t i, j; 2229 int elferr, first; |
2527 char idx[10]; 2528 2529 if (ed->flags & SOLARIS_FMT) 2530 PRT("\nHash Section: %s\n", s->name); 2531 else 2532 PRT("\nhash table (%s):\n", s->name); 2533 2534 /* --- 33 unchanged lines hidden (view full) --- 2568 } 2569 bucket = &buf[2]; 2570 chain = &buf[2 + nbucket]; 2571 2572 if (ed->flags & SOLARIS_FMT) { 2573 maxl = 0; 2574 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2575 err(EXIT_FAILURE, "calloc failed"); | 2230 char idx[10]; 2231 2232 if (ed->flags & SOLARIS_FMT) 2233 PRT("\nHash Section: %s\n", s->name); 2234 else 2235 PRT("\nhash table (%s):\n", s->name); 2236 2237 /* --- 33 unchanged lines hidden (view full) --- 2271 } 2272 bucket = &buf[2]; 2273 chain = &buf[2 + nbucket]; 2274 2275 if (ed->flags & SOLARIS_FMT) { 2276 maxl = 0; 2277 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2278 err(EXIT_FAILURE, "calloc failed"); |
2576 for (i = 0; (uint64_t)i < nbucket; i++) 2577 for (j = bucket[i]; j > 0 && (uint64_t)j < nchain; 2578 j = chain[j]) | 2279 for (i = 0; i < nbucket; i++) 2280 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) |
2579 if (++bl[i] > maxl) 2580 maxl = bl[i]; 2581 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2582 err(EXIT_FAILURE, "calloc failed"); | 2281 if (++bl[i] > maxl) 2282 maxl = bl[i]; 2283 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2284 err(EXIT_FAILURE, "calloc failed"); |
2583 for (i = 0; (uint64_t)i < nbucket; i++) | 2285 for (i = 0; i < nbucket; i++) |
2584 c[bl[i]]++; 2585 PRT(" bucket symndx name\n"); | 2286 c[bl[i]]++; 2287 PRT(" bucket symndx name\n"); |
2586 for (i = 0; (uint64_t)i < nbucket; i++) { | 2288 for (i = 0; i < nbucket; i++) { |
2587 first = 1; | 2289 first = 1; |
2588 for (j = bucket[i]; j > 0 && (uint64_t)j < nchain; 2589 j = chain[j]) { | 2290 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) { |
2590 if (first) { | 2291 if (first) { |
2591 PRT("%10d ", i); | 2292 PRT("%10zu ", i); |
2592 first = 0; 2593 } else 2594 PRT(" "); | 2293 first = 0; 2294 } else 2295 PRT(" "); |
2595 snprintf(idx, sizeof(idx), "[%d]", j); | 2296 snprintf(idx, sizeof(idx), "[%zu]", (size_t)j); |
2596 PRT("%-10s ", idx); 2597 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2598 } 2599 } 2600 PRT("\n"); 2601 total = 0; | 2297 PRT("%-10s ", idx); 2298 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2299 } 2300 } 2301 PRT("\n"); 2302 total = 0; |
2602 for (i = 0; (uint64_t)i <= maxl; i++) { | 2303 for (i = 0; i <= maxl; i++) { |
2603 total += c[i] * i; | 2304 total += c[i] * i; |
2604 PRT("%10ju buckets contain %8d symbols\n", | 2305 PRT("%10ju buckets contain %8zu symbols\n", |
2605 (uintmax_t)c[i], i); 2606 } 2607 PRT("%10ju buckets %8ju symbols (globals)\n", 2608 (uintmax_t)nbucket, (uintmax_t)total); 2609 } else { 2610 PRT("\nnbucket: %ju\n", (uintmax_t)nbucket); 2611 PRT("nchain: %ju\n\n", (uintmax_t)nchain); | 2306 (uintmax_t)c[i], i); 2307 } 2308 PRT("%10ju buckets %8ju symbols (globals)\n", 2309 (uintmax_t)nbucket, (uintmax_t)total); 2310 } else { 2311 PRT("\nnbucket: %ju\n", (uintmax_t)nbucket); 2312 PRT("nchain: %ju\n\n", (uintmax_t)nchain); |
2612 for (i = 0; (uint64_t)i < nbucket; i++) 2613 PRT("bucket[%d]:\n\t%ju\n\n", i, (uintmax_t)bucket[i]); 2614 for (i = 0; (uint64_t)i < nchain; i++) 2615 PRT("chain[%d]:\n\t%ju\n\n", i, (uintmax_t)chain[i]); | 2313 for (i = 0; i < nbucket; i++) 2314 PRT("bucket[%zu]:\n\t%ju\n\n", i, (uintmax_t)bucket[i]); 2315 for (i = 0; i < nchain; i++) 2316 PRT("chain[%zu]:\n\t%ju\n\n", i, (uintmax_t)chain[i]); |
2616 } 2617 2618} 2619 2620/* 2621 * Dump a GNU hash table. 2622 */ 2623static void 2624elf_print_gnu_hash(struct elfdump *ed, struct section *s) 2625{ 2626 struct section *ds; 2627 Elf_Data *data; 2628 uint32_t *buf; 2629 uint32_t *bucket, *chain; 2630 uint32_t nbucket, nchain, symndx, maskwords, shift2; 2631 uint32_t *bl, *c, maxl, total; | 2317 } 2318 2319} 2320 2321/* 2322 * Dump a GNU hash table. 2323 */ 2324static void 2325elf_print_gnu_hash(struct elfdump *ed, struct section *s) 2326{ 2327 struct section *ds; 2328 Elf_Data *data; 2329 uint32_t *buf; 2330 uint32_t *bucket, *chain; 2331 uint32_t nbucket, nchain, symndx, maskwords, shift2; 2332 uint32_t *bl, *c, maxl, total; |
2632 int i, j, first, elferr, dynsymcount; | 2333 uint32_t i, j; 2334 int first, elferr, dynsymcount; |
2633 char idx[10]; 2634 2635 if (ed->flags & SOLARIS_FMT) 2636 PRT("\nGNU Hash Section: %s\n", s->name); 2637 else 2638 PRT("\ngnu hash table (%s):\n", s->name); 2639 (void) elf_errno(); 2640 if ((data = elf_getdata(s->scn, NULL)) == NULL) { --- 8 unchanged lines hidden (view full) --- 2649 return; 2650 } 2651 buf = data->d_buf; 2652 nbucket = buf[0]; 2653 symndx = buf[1]; 2654 maskwords = buf[2]; 2655 shift2 = buf[3]; 2656 buf += 4; | 2335 char idx[10]; 2336 2337 if (ed->flags & SOLARIS_FMT) 2338 PRT("\nGNU Hash Section: %s\n", s->name); 2339 else 2340 PRT("\ngnu hash table (%s):\n", s->name); 2341 (void) elf_errno(); 2342 if ((data = elf_getdata(s->scn, NULL)) == NULL) { --- 8 unchanged lines hidden (view full) --- 2351 return; 2352 } 2353 buf = data->d_buf; 2354 nbucket = buf[0]; 2355 symndx = buf[1]; 2356 maskwords = buf[2]; 2357 shift2 = buf[3]; 2358 buf += 4; |
2359 if (s->link >= ed->shnum) { 2360 warnx("Malformed .gnu.hash section"); 2361 return; 2362 } |
|
2657 ds = &ed->sl[s->link]; 2658 if (!get_ent_count(ds, &dynsymcount)) 2659 return; | 2363 ds = &ed->sl[s->link]; 2364 if (!get_ent_count(ds, &dynsymcount)) 2365 return; |
2366 if (symndx >= (uint32_t)dynsymcount) { 2367 warnx("Malformed .gnu.hash section"); 2368 return; 2369 } |
|
2660 nchain = dynsymcount - symndx; 2661 if (data->d_size != 4 * sizeof(uint32_t) + maskwords * 2662 (ed->ec == ELFCLASS32 ? sizeof(uint32_t) : sizeof(uint64_t)) + | 2370 nchain = dynsymcount - symndx; 2371 if (data->d_size != 4 * sizeof(uint32_t) + maskwords * 2372 (ed->ec == ELFCLASS32 ? sizeof(uint32_t) : sizeof(uint64_t)) + |
2663 (nbucket + nchain) * sizeof(uint32_t)) { | 2373 ((uint64_t)nbucket + (uint64_t)nchain) * sizeof(uint32_t)) { |
2664 warnx("Malformed .gnu.hash section"); 2665 return; 2666 } 2667 bucket = buf + (ed->ec == ELFCLASS32 ? maskwords : maskwords * 2); 2668 chain = bucket + nbucket; 2669 2670 if (ed->flags & SOLARIS_FMT) { 2671 maxl = 0; 2672 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2673 err(EXIT_FAILURE, "calloc failed"); | 2374 warnx("Malformed .gnu.hash section"); 2375 return; 2376 } 2377 bucket = buf + (ed->ec == ELFCLASS32 ? maskwords : maskwords * 2); 2378 chain = bucket + nbucket; 2379 2380 if (ed->flags & SOLARIS_FMT) { 2381 maxl = 0; 2382 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2383 err(EXIT_FAILURE, "calloc failed"); |
2674 for (i = 0; (uint32_t)i < nbucket; i++) 2675 for (j = bucket[i]; 2676 j > 0 && (uint32_t)j - symndx < nchain; 2677 j++) { | 2384 for (i = 0; i < nbucket; i++) 2385 for (j = bucket[i]; j > 0 && j - symndx < nchain; j++) { |
2678 if (++bl[i] > maxl) 2679 maxl = bl[i]; 2680 if (chain[j - symndx] & 1) 2681 break; 2682 } 2683 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2684 err(EXIT_FAILURE, "calloc failed"); | 2386 if (++bl[i] > maxl) 2387 maxl = bl[i]; 2388 if (chain[j - symndx] & 1) 2389 break; 2390 } 2391 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2392 err(EXIT_FAILURE, "calloc failed"); |
2685 for (i = 0; (uint32_t)i < nbucket; i++) | 2393 for (i = 0; i < nbucket; i++) |
2686 c[bl[i]]++; 2687 PRT(" bucket symndx name\n"); | 2394 c[bl[i]]++; 2395 PRT(" bucket symndx name\n"); |
2688 for (i = 0; (uint32_t)i < nbucket; i++) { | 2396 for (i = 0; i < nbucket; i++) { |
2689 first = 1; | 2397 first = 1; |
2690 for (j = bucket[i]; 2691 j > 0 && (uint32_t)j - symndx < nchain; 2692 j++) { | 2398 for (j = bucket[i]; j > 0 && j - symndx < nchain; j++) { |
2693 if (first) { 2694 PRT("%10d ", i); 2695 first = 0; 2696 } else 2697 PRT(" "); 2698 snprintf(idx, sizeof(idx), "[%d]", j ); 2699 PRT("%-10s ", idx); 2700 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2701 if (chain[j - symndx] & 1) 2702 break; 2703 } 2704 } 2705 PRT("\n"); 2706 total = 0; | 2399 if (first) { 2400 PRT("%10d ", i); 2401 first = 0; 2402 } else 2403 PRT(" "); 2404 snprintf(idx, sizeof(idx), "[%d]", j ); 2405 PRT("%-10s ", idx); 2406 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2407 if (chain[j - symndx] & 1) 2408 break; 2409 } 2410 } 2411 PRT("\n"); 2412 total = 0; |
2707 for (i = 0; (uint32_t)i <= maxl; i++) { | 2413 for (i = 0; i <= maxl; i++) { |
2708 total += c[i] * i; 2709 PRT("%10u buckets contain %8d symbols\n", c[i], i); 2710 } 2711 PRT("%10u buckets %8u symbols (globals)\n", nbucket, 2712 total); 2713 } else { 2714 PRT("\nnbucket: %u\n", nbucket); 2715 PRT("symndx: %u\n", symndx); 2716 PRT("maskwords: %u\n", maskwords); 2717 PRT("shift2: %u\n", shift2); 2718 PRT("nchain: %u\n\n", nchain); | 2414 total += c[i] * i; 2415 PRT("%10u buckets contain %8d symbols\n", c[i], i); 2416 } 2417 PRT("%10u buckets %8u symbols (globals)\n", nbucket, 2418 total); 2419 } else { 2420 PRT("\nnbucket: %u\n", nbucket); 2421 PRT("symndx: %u\n", symndx); 2422 PRT("maskwords: %u\n", maskwords); 2423 PRT("shift2: %u\n", shift2); 2424 PRT("nchain: %u\n\n", nchain); |
2719 for (i = 0; (uint32_t)i < nbucket; i++) | 2425 for (i = 0; i < nbucket; i++) |
2720 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); | 2426 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); |
2721 for (i = 0; (uint32_t)i < nchain; i++) | 2427 for (i = 0; i < nchain; i++) |
2722 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); 2723 } 2724} 2725 2726/* 2727 * Dump hash tables. 2728 */ 2729static void 2730elf_print_hash(struct elfdump *ed) 2731{ 2732 struct section *s; | 2428 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); 2429 } 2430} 2431 2432/* 2433 * Dump hash tables. 2434 */ 2435static void 2436elf_print_hash(struct elfdump *ed) 2437{ 2438 struct section *s; |
2733 int i; | 2439 size_t i; |
2734 | 2440 |
2735 for (i = 0; (size_t)i < ed->shnum; i++) { | 2441 for (i = 0; i < ed->shnum; i++) { |
2736 s = &ed->sl[i]; 2737 if ((s->type == SHT_HASH || s->type == SHT_GNU_HASH) && 2738 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { 2739 if (s->type == SHT_GNU_HASH) 2740 elf_print_gnu_hash(ed, s); 2741 else if (ed->ehdr.e_machine == EM_ALPHA && 2742 s->entsize == 8) 2743 elf_print_svr4_hash64(ed, s); --- 166 unchanged lines hidden (view full) --- 2910 2911/* 2912 * Dump the symbol-versioning sections. 2913 */ 2914static void 2915elf_print_symver(struct elfdump *ed) 2916{ 2917 struct section *s; | 2442 s = &ed->sl[i]; 2443 if ((s->type == SHT_HASH || s->type == SHT_GNU_HASH) && 2444 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { 2445 if (s->type == SHT_GNU_HASH) 2446 elf_print_gnu_hash(ed, s); 2447 else if (ed->ehdr.e_machine == EM_ALPHA && 2448 s->entsize == 8) 2449 elf_print_svr4_hash64(ed, s); --- 166 unchanged lines hidden (view full) --- 2616 2617/* 2618 * Dump the symbol-versioning sections. 2619 */ 2620static void 2621elf_print_symver(struct elfdump *ed) 2622{ 2623 struct section *s; |
2918 int i; | 2624 size_t i; |
2919 | 2625 |
2920 for (i = 0; (size_t)i < ed->shnum; i++) { | 2626 for (i = 0; i < ed->shnum; i++) { |
2921 s = &ed->sl[i]; 2922 if (!STAILQ_EMPTY(&ed->snl) && !find_name(ed, s->name)) 2923 continue; 2924 if (s->type == SHT_SUNW_verdef) 2925 elf_print_verdef(ed, s); 2926 if (s->type == SHT_SUNW_verneed) 2927 elf_print_verneed(ed, s); 2928 } --- 44 unchanged lines hidden --- | 2627 s = &ed->sl[i]; 2628 if (!STAILQ_EMPTY(&ed->snl) && !find_name(ed, s->name)) 2629 continue; 2630 if (s->type == SHT_SUNW_verdef) 2631 elf_print_verdef(ed, s); 2632 if (s->type == SHT_SUNW_verneed) 2633 elf_print_verneed(ed, s); 2634 } --- 44 unchanged lines hidden --- |