1 /* readelf.c -- display contents of an ELF format file 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 3 Free Software Foundation, Inc. 4 5 Originally developed by Eric Youngdale <eric@andante.jic.com> 6 Modifications by Nick Clifton <nickc@redhat.com> 7 8 This file is part of GNU Binutils. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 23 02110-1301, USA. */ 24 25 /* The difference between readelf and objdump: 26 27 Both programs are capable of displaying the contents of ELF format files, 28 so why does the binutils project have two file dumpers ? 29 30 The reason is that objdump sees an ELF file through a BFD filter of the 31 world; if BFD has a bug where, say, it disagrees about a machine constant 32 in e_flags, then the odds are good that it will remain internally 33 consistent. The linker sees it the BFD way, objdump sees it the BFD way, 34 GAS sees it the BFD way. There was need for a tool to go find out what 35 the file actually says. 36 37 This is why the readelf program does not link against the BFD library - it 38 exists as an independent program to help verify the correct working of BFD. 39 40 There is also the case that readelf can provide more information about an 41 ELF file than is provided by objdump. In particular it can display DWARF 42 debugging information which (at the moment) objdump cannot. */ 43 44 #include <assert.h> 45 #include <sys/types.h> 46 #include <sys/stat.h> 47 #include <stdio.h> 48 #include <time.h> 49 50 #if __GNUC__ >= 2 51 /* Define BFD64 here, even if our default architecture is 32 bit ELF 52 as this will allow us to read in and parse 64bit and 32bit ELF files. 53 Only do this if we believe that the compiler can support a 64 bit 54 data type. For now we only rely on GCC being able to do this. */ 55 #define BFD64 56 #endif 57 58 #include "dwarf.h" 59 60 #include "elf/common.h" 61 #include "elf/external.h" 62 #include "elf/internal.h" 63 64 /* The following headers use the elf/reloc-macros.h file to 65 automatically generate relocation recognition functions 66 such as elf_mips_reloc_type() */ 67 68 #define RELOC_MACROS_GEN_FUNC 69 70 #include "elf/alpha.h" 71 #include "elf/arc.h" 72 #include "elf/arm.h" 73 #include "elf/avr.h" 74 #include "elf/bfin.h" 75 #include "elf/cris.h" 76 #include "elf/d10v.h" 77 #include "elf/d30v.h" 78 #include "elf/dlx.h" 79 #include "elf/fr30.h" 80 #include "elf/frv.h" 81 #include "elf/h8.h" 82 #include "elf/hppa.h" 83 #include "elf/i386.h" 84 #include "elf/i370.h" 85 #include "elf/i860.h" 86 #include "elf/i960.h" 87 #include "elf/ia64.h" 88 #include "elf/ip2k.h" 89 #include "elf/m32c.h" 90 #include "elf/m32r.h" 91 #include "elf/m68k.h" 92 #include "elf/m68hc11.h" 93 #include "elf/mcore.h" 94 #include "elf/mips.h" 95 #include "elf/mmix.h" 96 #include "elf/mn10200.h" 97 #include "elf/mn10300.h" 98 #include "elf/mt.h" 99 #include "elf/msp430.h" 100 #include "elf/or32.h" 101 #include "elf/pj.h" 102 #include "elf/ppc.h" 103 #include "elf/ppc64.h" 104 #include "elf/s390.h" 105 #include "elf/sh.h" 106 #include "elf/sparc.h" 107 #include "elf/v850.h" 108 #include "elf/vax.h" 109 #include "elf/x86-64.h" 110 #include "elf/xstormy16.h" 111 #include "elf/crx.h" 112 #include "elf/iq2000.h" 113 #include "elf/xtensa.h" 114 115 #include "aout/ar.h" 116 117 #include "bucomm.h" 118 #include "getopt.h" 119 #include "libiberty.h" 120 121 char *program_name = "readelf"; 122 static long archive_file_offset; 123 static unsigned long archive_file_size; 124 static unsigned long dynamic_addr; 125 static bfd_size_type dynamic_size; 126 static unsigned int dynamic_nent; 127 static char *dynamic_strings; 128 static unsigned long dynamic_strings_length; 129 static char *string_table; 130 static unsigned long string_table_length; 131 static unsigned long num_dynamic_syms; 132 static Elf_Internal_Sym *dynamic_symbols; 133 static Elf_Internal_Syminfo *dynamic_syminfo; 134 static unsigned long dynamic_syminfo_offset; 135 static unsigned int dynamic_syminfo_nent; 136 static char program_interpreter[64]; 137 static bfd_vma dynamic_info[DT_JMPREL + 1]; 138 static bfd_vma version_info[16]; 139 static Elf_Internal_Ehdr elf_header; 140 static Elf_Internal_Shdr *section_headers; 141 static Elf_Internal_Phdr *program_headers; 142 static Elf_Internal_Dyn *dynamic_section; 143 static Elf_Internal_Shdr *symtab_shndx_hdr; 144 static int show_name; 145 static int do_dynamic; 146 static int do_syms; 147 static int do_reloc; 148 static int do_sections; 149 static int do_section_groups; 150 static int do_section_details; 151 static int do_segments; 152 static int do_unwind; 153 static int do_using_dynamic; 154 static int do_header; 155 static int do_dump; 156 static int do_version; 157 static int do_wide; 158 static int do_histogram; 159 static int do_debugging; 160 static int do_arch; 161 static int do_notes; 162 static int is_32bit_elf; 163 164 struct group_list 165 { 166 struct group_list *next; 167 unsigned int section_index; 168 }; 169 170 struct group 171 { 172 struct group_list *root; 173 unsigned int group_index; 174 }; 175 176 static size_t group_count; 177 static struct group *section_groups; 178 static struct group **section_headers_groups; 179 180 /* A linked list of the section names for which dumps were requested 181 by name. */ 182 struct dump_list_entry 183 { 184 char *name; 185 int type; 186 struct dump_list_entry *next; 187 }; 188 static struct dump_list_entry *dump_sects_byname; 189 190 /* A dynamic array of flags indicating for which sections a hex dump 191 has been requested (via the -x switch) and/or a disassembly dump 192 (via the -i switch). */ 193 char *cmdline_dump_sects = NULL; 194 unsigned num_cmdline_dump_sects = 0; 195 196 /* A dynamic array of flags indicating for which sections a dump of 197 some kind has been requested. It is reset on a per-object file 198 basis and then initialised from the cmdline_dump_sects array, 199 the results of interpreting the -w switch, and the 200 dump_sects_byname list. */ 201 char *dump_sects = NULL; 202 unsigned int num_dump_sects = 0; 203 204 #define HEX_DUMP (1 << 0) 205 #define DISASS_DUMP (1 << 1) 206 #define DEBUG_DUMP (1 << 2) 207 208 /* How to print a vma value. */ 209 typedef enum print_mode 210 { 211 HEX, 212 DEC, 213 DEC_5, 214 UNSIGNED, 215 PREFIX_HEX, 216 FULL_HEX, 217 LONG_HEX 218 } 219 print_mode; 220 221 static void (*byte_put) (unsigned char *, bfd_vma, int); 222 223 #define UNKNOWN -1 224 225 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \ 226 ((X)->sh_name >= string_table_length \ 227 ? "<corrupt>" : string_table + (X)->sh_name)) 228 229 /* Given st_shndx I, map to section_headers index. */ 230 #define SECTION_HEADER_INDEX(I) \ 231 ((I) < SHN_LORESERVE \ 232 ? (I) \ 233 : ((I) <= SHN_HIRESERVE \ 234 ? 0 \ 235 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE))) 236 237 /* Reverse of the above. */ 238 #define SECTION_HEADER_NUM(N) \ 239 ((N) < SHN_LORESERVE \ 240 ? (N) \ 241 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE)) 242 243 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I)) 244 245 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */ 246 247 #define BYTE_GET(field) byte_get (field, sizeof (field)) 248 249 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0])) 250 251 #define GET_ELF_SYMBOLS(file, section) \ 252 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \ 253 : get_64bit_elf_symbols (file, section)) 254 255 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length)) 256 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has 257 already been called and verified that the string exists. */ 258 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset) 259 260 /* This is just a bit of syntatic sugar. */ 261 #define streq(a,b) (strcmp ((a), (b)) == 0) 262 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0) 263 264 static void * 265 get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb, 266 const char *reason) 267 { 268 void *mvar; 269 270 if (size == 0 || nmemb == 0) 271 return NULL; 272 273 if (fseek (file, archive_file_offset + offset, SEEK_SET)) 274 { 275 error (_("Unable to seek to 0x%lx for %s\n"), 276 archive_file_offset + offset, reason); 277 return NULL; 278 } 279 280 mvar = var; 281 if (mvar == NULL) 282 { 283 /* Check for overflow. */ 284 if (nmemb < (~(size_t) 0 - 1) / size) 285 /* + 1 so that we can '\0' terminate invalid string table sections. */ 286 mvar = malloc (size * nmemb + 1); 287 288 if (mvar == NULL) 289 { 290 error (_("Out of memory allocating 0x%lx bytes for %s\n"), 291 (unsigned long)(size * nmemb), reason); 292 return NULL; 293 } 294 295 ((char *) mvar)[size * nmemb] = '\0'; 296 } 297 298 if (fread (mvar, size, nmemb, file) != nmemb) 299 { 300 error (_("Unable to read in 0x%lx bytes of %s\n"), 301 (unsigned long)(size * nmemb), reason); 302 if (mvar != var) 303 free (mvar); 304 return NULL; 305 } 306 307 return mvar; 308 } 309 310 static void 311 byte_put_little_endian (unsigned char *field, bfd_vma value, int size) 312 { 313 switch (size) 314 { 315 case 8: 316 field[7] = (((value >> 24) >> 24) >> 8) & 0xff; 317 field[6] = ((value >> 24) >> 24) & 0xff; 318 field[5] = ((value >> 24) >> 16) & 0xff; 319 field[4] = ((value >> 24) >> 8) & 0xff; 320 /* Fall through. */ 321 case 4: 322 field[3] = (value >> 24) & 0xff; 323 field[2] = (value >> 16) & 0xff; 324 /* Fall through. */ 325 case 2: 326 field[1] = (value >> 8) & 0xff; 327 /* Fall through. */ 328 case 1: 329 field[0] = value & 0xff; 330 break; 331 332 default: 333 error (_("Unhandled data length: %d\n"), size); 334 abort (); 335 } 336 } 337 338 #if defined BFD64 && !BFD_HOST_64BIT_LONG 339 static int 340 print_dec_vma (bfd_vma vma, int is_signed) 341 { 342 char buf[40]; 343 char *bufp = buf; 344 int nc = 0; 345 346 if (is_signed && (bfd_signed_vma) vma < 0) 347 { 348 vma = -vma; 349 putchar ('-'); 350 nc = 1; 351 } 352 353 do 354 { 355 *bufp++ = '0' + vma % 10; 356 vma /= 10; 357 } 358 while (vma != 0); 359 nc += bufp - buf; 360 361 while (bufp > buf) 362 putchar (*--bufp); 363 return nc; 364 } 365 366 static int 367 print_hex_vma (bfd_vma vma) 368 { 369 char buf[32]; 370 char *bufp = buf; 371 int nc; 372 373 do 374 { 375 char digit = '0' + (vma & 0x0f); 376 if (digit > '9') 377 digit += 'a' - '0' - 10; 378 *bufp++ = digit; 379 vma >>= 4; 380 } 381 while (vma != 0); 382 nc = bufp - buf; 383 384 while (bufp > buf) 385 putchar (*--bufp); 386 return nc; 387 } 388 #endif 389 390 /* Print a VMA value. */ 391 static int 392 print_vma (bfd_vma vma, print_mode mode) 393 { 394 #ifdef BFD64 395 if (is_32bit_elf) 396 #endif 397 { 398 switch (mode) 399 { 400 case FULL_HEX: 401 return printf ("0x%8.8lx", (unsigned long) vma); 402 403 case LONG_HEX: 404 return printf ("%8.8lx", (unsigned long) vma); 405 406 case DEC_5: 407 if (vma <= 99999) 408 return printf ("%5ld", (long) vma); 409 /* Drop through. */ 410 411 case PREFIX_HEX: 412 return printf ("0x%lx", (unsigned long) vma); 413 414 case HEX: 415 return printf ("%lx", (unsigned long) vma); 416 417 case DEC: 418 return printf ("%ld", (unsigned long) vma); 419 420 case UNSIGNED: 421 return printf ("%lu", (unsigned long) vma); 422 } 423 } 424 #ifdef BFD64 425 else 426 { 427 int nc = 0; 428 429 switch (mode) 430 { 431 case FULL_HEX: 432 nc = printf ("0x"); 433 /* Drop through. */ 434 435 case LONG_HEX: 436 printf_vma (vma); 437 return nc + 16; 438 439 case PREFIX_HEX: 440 nc = printf ("0x"); 441 /* Drop through. */ 442 443 case HEX: 444 #if BFD_HOST_64BIT_LONG 445 return nc + printf ("%lx", vma); 446 #else 447 return nc + print_hex_vma (vma); 448 #endif 449 450 case DEC: 451 #if BFD_HOST_64BIT_LONG 452 return printf ("%ld", vma); 453 #else 454 return print_dec_vma (vma, 1); 455 #endif 456 457 case DEC_5: 458 #if BFD_HOST_64BIT_LONG 459 if (vma <= 99999) 460 return printf ("%5ld", vma); 461 else 462 return printf ("%#lx", vma); 463 #else 464 if (vma <= 99999) 465 return printf ("%5ld", _bfd_int64_low (vma)); 466 else 467 return print_hex_vma (vma); 468 #endif 469 470 case UNSIGNED: 471 #if BFD_HOST_64BIT_LONG 472 return printf ("%lu", vma); 473 #else 474 return print_dec_vma (vma, 0); 475 #endif 476 } 477 } 478 #endif 479 return 0; 480 } 481 482 /* Display a symbol on stdout. If do_wide is not true then 483 format the symbol to be at most WIDTH characters, 484 truncating as necessary. If WIDTH is negative then 485 format the string to be exactly - WIDTH characters, 486 truncating or padding as necessary. */ 487 488 static void 489 print_symbol (int width, const char *symbol) 490 { 491 if (do_wide) 492 printf ("%s", symbol); 493 else if (width < 0) 494 printf ("%-*.*s", width, width, symbol); 495 else 496 printf ("%-.*s", width, symbol); 497 } 498 499 static void 500 byte_put_big_endian (unsigned char *field, bfd_vma value, int size) 501 { 502 switch (size) 503 { 504 case 8: 505 field[7] = value & 0xff; 506 field[6] = (value >> 8) & 0xff; 507 field[5] = (value >> 16) & 0xff; 508 field[4] = (value >> 24) & 0xff; 509 value >>= 16; 510 value >>= 16; 511 /* Fall through. */ 512 case 4: 513 field[3] = value & 0xff; 514 field[2] = (value >> 8) & 0xff; 515 value >>= 16; 516 /* Fall through. */ 517 case 2: 518 field[1] = value & 0xff; 519 value >>= 8; 520 /* Fall through. */ 521 case 1: 522 field[0] = value & 0xff; 523 break; 524 525 default: 526 error (_("Unhandled data length: %d\n"), size); 527 abort (); 528 } 529 } 530 531 /* Return a pointer to section NAME, or NULL if no such section exists. */ 532 533 static Elf_Internal_Shdr * 534 find_section (const char *name) 535 { 536 unsigned int i; 537 538 for (i = 0; i < elf_header.e_shnum; i++) 539 if (streq (SECTION_NAME (section_headers + i), name)) 540 return section_headers + i; 541 542 return NULL; 543 } 544 545 /* Guess the relocation size commonly used by the specific machines. */ 546 547 static int 548 guess_is_rela (unsigned long e_machine) 549 { 550 switch (e_machine) 551 { 552 /* Targets that use REL relocations. */ 553 case EM_ARM: 554 case EM_386: 555 case EM_486: 556 case EM_960: 557 case EM_DLX: 558 case EM_OPENRISC: 559 case EM_OR32: 560 case EM_CYGNUS_M32R: 561 case EM_D10V: 562 case EM_CYGNUS_D10V: 563 case EM_MIPS: 564 case EM_MIPS_RS3_LE: 565 return FALSE; 566 567 /* Targets that use RELA relocations. */ 568 case EM_68K: 569 case EM_H8_300: 570 case EM_H8_300H: 571 case EM_H8S: 572 case EM_SPARC32PLUS: 573 case EM_SPARCV9: 574 case EM_SPARC: 575 case EM_PPC: 576 case EM_PPC64: 577 case EM_V850: 578 case EM_CYGNUS_V850: 579 case EM_D30V: 580 case EM_CYGNUS_D30V: 581 case EM_MN10200: 582 case EM_CYGNUS_MN10200: 583 case EM_MN10300: 584 case EM_CYGNUS_MN10300: 585 case EM_FR30: 586 case EM_CYGNUS_FR30: 587 case EM_CYGNUS_FRV: 588 case EM_SH: 589 case EM_ALPHA: 590 case EM_MCORE: 591 case EM_IA_64: 592 case EM_AVR: 593 case EM_AVR_OLD: 594 case EM_CRIS: 595 case EM_860: 596 case EM_X86_64: 597 case EM_S390: 598 case EM_S390_OLD: 599 case EM_MMIX: 600 case EM_MSP430: 601 case EM_MSP430_OLD: 602 case EM_XSTORMY16: 603 case EM_CRX: 604 case EM_VAX: 605 case EM_IP2K: 606 case EM_IP2K_OLD: 607 case EM_IQ2000: 608 case EM_XTENSA: 609 case EM_XTENSA_OLD: 610 case EM_M32R: 611 case EM_M32C: 612 case EM_MT: 613 case EM_BLACKFIN: 614 case EM_NIOS32: 615 case EM_ALTERA_NIOS2: 616 return TRUE; 617 618 case EM_MMA: 619 case EM_PCP: 620 case EM_NCPU: 621 case EM_NDR1: 622 case EM_STARCORE: 623 case EM_ME16: 624 case EM_ST100: 625 case EM_TINYJ: 626 case EM_FX66: 627 case EM_ST9PLUS: 628 case EM_ST7: 629 case EM_68HC16: 630 case EM_68HC11: 631 case EM_68HC08: 632 case EM_68HC05: 633 case EM_SVX: 634 case EM_ST19: 635 default: 636 warn (_("Don't know about relocations on this machine architecture\n")); 637 return FALSE; 638 } 639 } 640 641 static int 642 slurp_rela_relocs (FILE *file, 643 unsigned long rel_offset, 644 unsigned long rel_size, 645 Elf_Internal_Rela **relasp, 646 unsigned long *nrelasp) 647 { 648 Elf_Internal_Rela *relas; 649 unsigned long nrelas; 650 unsigned int i; 651 652 if (is_32bit_elf) 653 { 654 Elf32_External_Rela *erelas; 655 656 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs")); 657 if (!erelas) 658 return 0; 659 660 nrelas = rel_size / sizeof (Elf32_External_Rela); 661 662 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela)); 663 664 if (relas == NULL) 665 { 666 free (erelas); 667 error (_("out of memory parsing relocs")); 668 return 0; 669 } 670 671 for (i = 0; i < nrelas; i++) 672 { 673 relas[i].r_offset = BYTE_GET (erelas[i].r_offset); 674 relas[i].r_info = BYTE_GET (erelas[i].r_info); 675 relas[i].r_addend = BYTE_GET (erelas[i].r_addend); 676 } 677 678 free (erelas); 679 } 680 else 681 { 682 Elf64_External_Rela *erelas; 683 684 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs")); 685 if (!erelas) 686 return 0; 687 688 nrelas = rel_size / sizeof (Elf64_External_Rela); 689 690 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela)); 691 692 if (relas == NULL) 693 { 694 free (erelas); 695 error (_("out of memory parsing relocs")); 696 return 0; 697 } 698 699 for (i = 0; i < nrelas; i++) 700 { 701 relas[i].r_offset = BYTE_GET (erelas[i].r_offset); 702 relas[i].r_info = BYTE_GET (erelas[i].r_info); 703 relas[i].r_addend = BYTE_GET (erelas[i].r_addend); 704 } 705 706 free (erelas); 707 } 708 *relasp = relas; 709 *nrelasp = nrelas; 710 return 1; 711 } 712 713 static int 714 slurp_rel_relocs (FILE *file, 715 unsigned long rel_offset, 716 unsigned long rel_size, 717 Elf_Internal_Rela **relsp, 718 unsigned long *nrelsp) 719 { 720 Elf_Internal_Rela *rels; 721 unsigned long nrels; 722 unsigned int i; 723 724 if (is_32bit_elf) 725 { 726 Elf32_External_Rel *erels; 727 728 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs")); 729 if (!erels) 730 return 0; 731 732 nrels = rel_size / sizeof (Elf32_External_Rel); 733 734 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela)); 735 736 if (rels == NULL) 737 { 738 free (erels); 739 error (_("out of memory parsing relocs")); 740 return 0; 741 } 742 743 for (i = 0; i < nrels; i++) 744 { 745 rels[i].r_offset = BYTE_GET (erels[i].r_offset); 746 rels[i].r_info = BYTE_GET (erels[i].r_info); 747 rels[i].r_addend = 0; 748 } 749 750 free (erels); 751 } 752 else 753 { 754 Elf64_External_Rel *erels; 755 756 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs")); 757 if (!erels) 758 return 0; 759 760 nrels = rel_size / sizeof (Elf64_External_Rel); 761 762 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela)); 763 764 if (rels == NULL) 765 { 766 free (erels); 767 error (_("out of memory parsing relocs")); 768 return 0; 769 } 770 771 for (i = 0; i < nrels; i++) 772 { 773 rels[i].r_offset = BYTE_GET (erels[i].r_offset); 774 rels[i].r_info = BYTE_GET (erels[i].r_info); 775 rels[i].r_addend = 0; 776 } 777 778 free (erels); 779 } 780 *relsp = rels; 781 *nrelsp = nrels; 782 return 1; 783 } 784 785 /* Display the contents of the relocation data found at the specified 786 offset. */ 787 788 static int 789 dump_relocations (FILE *file, 790 unsigned long rel_offset, 791 unsigned long rel_size, 792 Elf_Internal_Sym *symtab, 793 unsigned long nsyms, 794 char *strtab, 795 unsigned long strtablen, 796 int is_rela) 797 { 798 unsigned int i; 799 Elf_Internal_Rela *rels; 800 801 802 if (is_rela == UNKNOWN) 803 is_rela = guess_is_rela (elf_header.e_machine); 804 805 if (is_rela) 806 { 807 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size)) 808 return 0; 809 } 810 else 811 { 812 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size)) 813 return 0; 814 } 815 816 if (is_32bit_elf) 817 { 818 if (is_rela) 819 { 820 if (do_wide) 821 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n")); 822 else 823 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n")); 824 } 825 else 826 { 827 if (do_wide) 828 printf (_(" Offset Info Type Sym. Value Symbol's Name\n")); 829 else 830 printf (_(" Offset Info Type Sym.Value Sym. Name\n")); 831 } 832 } 833 else 834 { 835 if (is_rela) 836 { 837 if (do_wide) 838 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n")); 839 else 840 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n")); 841 } 842 else 843 { 844 if (do_wide) 845 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n")); 846 else 847 printf (_(" Offset Info Type Sym. Value Sym. Name\n")); 848 } 849 } 850 851 for (i = 0; i < rel_size; i++) 852 { 853 const char *rtype; 854 const char *rtype2 = NULL; 855 const char *rtype3 = NULL; 856 bfd_vma offset; 857 bfd_vma info; 858 bfd_vma symtab_index; 859 bfd_vma type; 860 bfd_vma type2 = 0; 861 bfd_vma type3 = 0; 862 863 offset = rels[i].r_offset; 864 info = rels[i].r_info; 865 866 if (is_32bit_elf) 867 { 868 type = ELF32_R_TYPE (info); 869 symtab_index = ELF32_R_SYM (info); 870 } 871 else 872 { 873 /* The #ifdef BFD64 below is to prevent a compile time warning. 874 We know that if we do not have a 64 bit data type that we 875 will never execute this code anyway. */ 876 #ifdef BFD64 877 if (elf_header.e_machine == EM_MIPS) 878 { 879 /* In little-endian objects, r_info isn't really a 64-bit 880 little-endian value: it has a 32-bit little-endian 881 symbol index followed by four individual byte fields. 882 Reorder INFO accordingly. */ 883 if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB) 884 info = (((info & 0xffffffff) << 32) 885 | ((info >> 56) & 0xff) 886 | ((info >> 40) & 0xff00) 887 | ((info >> 24) & 0xff0000) 888 | ((info >> 8) & 0xff000000)); 889 type = ELF64_MIPS_R_TYPE (info); 890 type2 = ELF64_MIPS_R_TYPE2 (info); 891 type3 = ELF64_MIPS_R_TYPE3 (info); 892 } 893 else if (elf_header.e_machine == EM_SPARCV9) 894 type = ELF64_R_TYPE_ID (info); 895 else 896 type = ELF64_R_TYPE (info); 897 898 symtab_index = ELF64_R_SYM (info); 899 #endif 900 } 901 902 if (is_32bit_elf) 903 { 904 #ifdef _bfd_int64_low 905 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info)); 906 #else 907 printf ("%8.8lx %8.8lx ", offset, info); 908 #endif 909 } 910 else 911 { 912 #ifdef _bfd_int64_low 913 printf (do_wide 914 ? "%8.8lx%8.8lx %8.8lx%8.8lx " 915 : "%4.4lx%8.8lx %4.4lx%8.8lx ", 916 _bfd_int64_high (offset), 917 _bfd_int64_low (offset), 918 _bfd_int64_high (info), 919 _bfd_int64_low (info)); 920 #else 921 printf (do_wide 922 ? "%16.16lx %16.16lx " 923 : "%12.12lx %12.12lx ", 924 offset, info); 925 #endif 926 } 927 928 switch (elf_header.e_machine) 929 { 930 default: 931 rtype = NULL; 932 break; 933 934 case EM_M32R: 935 case EM_CYGNUS_M32R: 936 rtype = elf_m32r_reloc_type (type); 937 break; 938 939 case EM_386: 940 case EM_486: 941 rtype = elf_i386_reloc_type (type); 942 break; 943 944 case EM_68HC11: 945 case EM_68HC12: 946 rtype = elf_m68hc11_reloc_type (type); 947 break; 948 949 case EM_68K: 950 rtype = elf_m68k_reloc_type (type); 951 break; 952 953 case EM_960: 954 rtype = elf_i960_reloc_type (type); 955 break; 956 957 case EM_AVR: 958 case EM_AVR_OLD: 959 rtype = elf_avr_reloc_type (type); 960 break; 961 962 case EM_OLD_SPARCV9: 963 case EM_SPARC32PLUS: 964 case EM_SPARCV9: 965 case EM_SPARC: 966 rtype = elf_sparc_reloc_type (type); 967 break; 968 969 case EM_V850: 970 case EM_CYGNUS_V850: 971 rtype = v850_reloc_type (type); 972 break; 973 974 case EM_D10V: 975 case EM_CYGNUS_D10V: 976 rtype = elf_d10v_reloc_type (type); 977 break; 978 979 case EM_D30V: 980 case EM_CYGNUS_D30V: 981 rtype = elf_d30v_reloc_type (type); 982 break; 983 984 case EM_DLX: 985 rtype = elf_dlx_reloc_type (type); 986 break; 987 988 case EM_SH: 989 rtype = elf_sh_reloc_type (type); 990 break; 991 992 case EM_MN10300: 993 case EM_CYGNUS_MN10300: 994 rtype = elf_mn10300_reloc_type (type); 995 break; 996 997 case EM_MN10200: 998 case EM_CYGNUS_MN10200: 999 rtype = elf_mn10200_reloc_type (type); 1000 break; 1001 1002 case EM_FR30: 1003 case EM_CYGNUS_FR30: 1004 rtype = elf_fr30_reloc_type (type); 1005 break; 1006 1007 case EM_CYGNUS_FRV: 1008 rtype = elf_frv_reloc_type (type); 1009 break; 1010 1011 case EM_MCORE: 1012 rtype = elf_mcore_reloc_type (type); 1013 break; 1014 1015 case EM_MMIX: 1016 rtype = elf_mmix_reloc_type (type); 1017 break; 1018 1019 case EM_MSP430: 1020 case EM_MSP430_OLD: 1021 rtype = elf_msp430_reloc_type (type); 1022 break; 1023 1024 case EM_PPC: 1025 rtype = elf_ppc_reloc_type (type); 1026 break; 1027 1028 case EM_PPC64: 1029 rtype = elf_ppc64_reloc_type (type); 1030 break; 1031 1032 case EM_MIPS: 1033 case EM_MIPS_RS3_LE: 1034 rtype = elf_mips_reloc_type (type); 1035 if (!is_32bit_elf) 1036 { 1037 rtype2 = elf_mips_reloc_type (type2); 1038 rtype3 = elf_mips_reloc_type (type3); 1039 } 1040 break; 1041 1042 case EM_ALPHA: 1043 rtype = elf_alpha_reloc_type (type); 1044 break; 1045 1046 case EM_ARM: 1047 rtype = elf_arm_reloc_type (type); 1048 break; 1049 1050 case EM_ARC: 1051 rtype = elf_arc_reloc_type (type); 1052 break; 1053 1054 case EM_PARISC: 1055 rtype = elf_hppa_reloc_type (type); 1056 break; 1057 1058 case EM_H8_300: 1059 case EM_H8_300H: 1060 case EM_H8S: 1061 rtype = elf_h8_reloc_type (type); 1062 break; 1063 1064 case EM_OPENRISC: 1065 case EM_OR32: 1066 rtype = elf_or32_reloc_type (type); 1067 break; 1068 1069 case EM_PJ: 1070 case EM_PJ_OLD: 1071 rtype = elf_pj_reloc_type (type); 1072 break; 1073 case EM_IA_64: 1074 rtype = elf_ia64_reloc_type (type); 1075 break; 1076 1077 case EM_CRIS: 1078 rtype = elf_cris_reloc_type (type); 1079 break; 1080 1081 case EM_860: 1082 rtype = elf_i860_reloc_type (type); 1083 break; 1084 1085 case EM_X86_64: 1086 rtype = elf_x86_64_reloc_type (type); 1087 break; 1088 1089 case EM_S370: 1090 rtype = i370_reloc_type (type); 1091 break; 1092 1093 case EM_S390_OLD: 1094 case EM_S390: 1095 rtype = elf_s390_reloc_type (type); 1096 break; 1097 1098 case EM_XSTORMY16: 1099 rtype = elf_xstormy16_reloc_type (type); 1100 break; 1101 1102 case EM_CRX: 1103 rtype = elf_crx_reloc_type (type); 1104 break; 1105 1106 case EM_VAX: 1107 rtype = elf_vax_reloc_type (type); 1108 break; 1109 1110 case EM_IP2K: 1111 case EM_IP2K_OLD: 1112 rtype = elf_ip2k_reloc_type (type); 1113 break; 1114 1115 case EM_IQ2000: 1116 rtype = elf_iq2000_reloc_type (type); 1117 break; 1118 1119 case EM_XTENSA_OLD: 1120 case EM_XTENSA: 1121 rtype = elf_xtensa_reloc_type (type); 1122 break; 1123 1124 case EM_M32C: 1125 rtype = elf_m32c_reloc_type (type); 1126 break; 1127 1128 case EM_MT: 1129 rtype = elf_mt_reloc_type (type); 1130 break; 1131 1132 case EM_BLACKFIN: 1133 rtype = elf_bfin_reloc_type (type); 1134 break; 1135 1136 } 1137 1138 if (rtype == NULL) 1139 #ifdef _bfd_int64_low 1140 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type)); 1141 #else 1142 printf (_("unrecognized: %-7lx"), type); 1143 #endif 1144 else 1145 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype); 1146 1147 if (elf_header.e_machine == EM_ALPHA 1148 && streq (rtype, "R_ALPHA_LITUSE") 1149 && is_rela) 1150 { 1151 switch (rels[i].r_addend) 1152 { 1153 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break; 1154 case LITUSE_ALPHA_BASE: rtype = "BASE"; break; 1155 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break; 1156 case LITUSE_ALPHA_JSR: rtype = "JSR"; break; 1157 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break; 1158 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break; 1159 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break; 1160 default: rtype = NULL; 1161 } 1162 if (rtype) 1163 printf (" (%s)", rtype); 1164 else 1165 { 1166 putchar (' '); 1167 printf (_("<unknown addend: %lx>"), 1168 (unsigned long) rels[i].r_addend); 1169 } 1170 } 1171 else if (symtab_index) 1172 { 1173 if (symtab == NULL || symtab_index >= nsyms) 1174 printf (" bad symbol index: %08lx", (unsigned long) symtab_index); 1175 else 1176 { 1177 Elf_Internal_Sym *psym; 1178 1179 psym = symtab + symtab_index; 1180 1181 printf (" "); 1182 print_vma (psym->st_value, LONG_HEX); 1183 printf (is_32bit_elf ? " " : " "); 1184 1185 if (psym->st_name == 0) 1186 { 1187 const char *sec_name = "<null>"; 1188 char name_buf[40]; 1189 1190 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION) 1191 { 1192 bfd_vma sec_index = (bfd_vma) -1; 1193 1194 if (psym->st_shndx < SHN_LORESERVE) 1195 sec_index = psym->st_shndx; 1196 else if (psym->st_shndx > SHN_HIRESERVE) 1197 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1 1198 - SHN_LORESERVE); 1199 1200 if (sec_index != (bfd_vma) -1) 1201 sec_name = SECTION_NAME (section_headers + sec_index); 1202 else if (psym->st_shndx == SHN_ABS) 1203 sec_name = "ABS"; 1204 else if (psym->st_shndx == SHN_COMMON) 1205 sec_name = "COMMON"; 1206 else if (elf_header.e_machine == EM_X86_64 1207 && psym->st_shndx == SHN_X86_64_LCOMMON) 1208 sec_name = "LARGE_COMMON"; 1209 else if (elf_header.e_machine == EM_IA_64 1210 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX 1211 && psym->st_shndx == SHN_IA_64_ANSI_COMMON) 1212 sec_name = "ANSI_COM"; 1213 else 1214 { 1215 sprintf (name_buf, "<section 0x%x>", 1216 (unsigned int) psym->st_shndx); 1217 sec_name = name_buf; 1218 } 1219 } 1220 print_symbol (22, sec_name); 1221 } 1222 else if (strtab == NULL) 1223 printf (_("<string table index: %3ld>"), psym->st_name); 1224 else if (psym->st_name >= strtablen) 1225 printf (_("<corrupt string table index: %3ld>"), psym->st_name); 1226 else 1227 print_symbol (22, strtab + psym->st_name); 1228 1229 if (is_rela) 1230 printf (" + %lx", (unsigned long) rels[i].r_addend); 1231 } 1232 } 1233 else if (is_rela) 1234 { 1235 printf ("%*c", is_32bit_elf ? 1236 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' '); 1237 print_vma (rels[i].r_addend, LONG_HEX); 1238 } 1239 1240 if (elf_header.e_machine == EM_SPARCV9 && streq (rtype, "R_SPARC_OLO10")) 1241 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info)); 1242 1243 putchar ('\n'); 1244 1245 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS) 1246 { 1247 printf (" Type2: "); 1248 1249 if (rtype2 == NULL) 1250 #ifdef _bfd_int64_low 1251 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2)); 1252 #else 1253 printf (_("unrecognized: %-7lx"), type2); 1254 #endif 1255 else 1256 printf ("%-17.17s", rtype2); 1257 1258 printf ("\n Type3: "); 1259 1260 if (rtype3 == NULL) 1261 #ifdef _bfd_int64_low 1262 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3)); 1263 #else 1264 printf (_("unrecognized: %-7lx"), type3); 1265 #endif 1266 else 1267 printf ("%-17.17s", rtype3); 1268 1269 putchar ('\n'); 1270 } 1271 } 1272 1273 free (rels); 1274 1275 return 1; 1276 } 1277 1278 static const char * 1279 get_mips_dynamic_type (unsigned long type) 1280 { 1281 switch (type) 1282 { 1283 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION"; 1284 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP"; 1285 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM"; 1286 case DT_MIPS_IVERSION: return "MIPS_IVERSION"; 1287 case DT_MIPS_FLAGS: return "MIPS_FLAGS"; 1288 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS"; 1289 case DT_MIPS_MSYM: return "MIPS_MSYM"; 1290 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT"; 1291 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST"; 1292 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO"; 1293 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO"; 1294 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO"; 1295 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO"; 1296 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO"; 1297 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM"; 1298 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO"; 1299 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP"; 1300 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS"; 1301 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO"; 1302 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE"; 1303 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO"; 1304 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC"; 1305 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO"; 1306 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM"; 1307 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO"; 1308 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM"; 1309 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO"; 1310 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS"; 1311 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT"; 1312 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB"; 1313 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX"; 1314 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX"; 1315 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX"; 1316 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX"; 1317 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS"; 1318 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE"; 1319 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN"; 1320 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE"; 1321 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR"; 1322 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX"; 1323 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE"; 1324 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE"; 1325 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC"; 1326 default: 1327 return NULL; 1328 } 1329 } 1330 1331 static const char * 1332 get_sparc64_dynamic_type (unsigned long type) 1333 { 1334 switch (type) 1335 { 1336 case DT_SPARC_REGISTER: return "SPARC_REGISTER"; 1337 default: 1338 return NULL; 1339 } 1340 } 1341 1342 static const char * 1343 get_ppc_dynamic_type (unsigned long type) 1344 { 1345 switch (type) 1346 { 1347 case DT_PPC_GOT: return "PPC_GOT"; 1348 default: 1349 return NULL; 1350 } 1351 } 1352 1353 static const char * 1354 get_ppc64_dynamic_type (unsigned long type) 1355 { 1356 switch (type) 1357 { 1358 case DT_PPC64_GLINK: return "PPC64_GLINK"; 1359 case DT_PPC64_OPD: return "PPC64_OPD"; 1360 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ"; 1361 default: 1362 return NULL; 1363 } 1364 } 1365 1366 static const char * 1367 get_parisc_dynamic_type (unsigned long type) 1368 { 1369 switch (type) 1370 { 1371 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP"; 1372 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS"; 1373 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK"; 1374 case DT_HP_UX10_INIT: return "HP_UX10_INIT"; 1375 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ"; 1376 case DT_HP_PREINIT: return "HP_PREINIT"; 1377 case DT_HP_PREINITSZ: return "HP_PREINITSZ"; 1378 case DT_HP_NEEDED: return "HP_NEEDED"; 1379 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP"; 1380 case DT_HP_CHECKSUM: return "HP_CHECKSUM"; 1381 case DT_HP_GST_SIZE: return "HP_GST_SIZE"; 1382 case DT_HP_GST_VERSION: return "HP_GST_VERSION"; 1383 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL"; 1384 case DT_HP_EPLTREL: return "HP_GST_EPLTREL"; 1385 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ"; 1386 case DT_HP_FILTERED: return "HP_FILTERED"; 1387 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS"; 1388 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED"; 1389 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD"; 1390 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT"; 1391 case DT_PLT: return "PLT"; 1392 case DT_PLT_SIZE: return "PLT_SIZE"; 1393 case DT_DLT: return "DLT"; 1394 case DT_DLT_SIZE: return "DLT_SIZE"; 1395 default: 1396 return NULL; 1397 } 1398 } 1399 1400 static const char * 1401 get_ia64_dynamic_type (unsigned long type) 1402 { 1403 switch (type) 1404 { 1405 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE"; 1406 default: 1407 return NULL; 1408 } 1409 } 1410 1411 static const char * 1412 get_alpha_dynamic_type (unsigned long type) 1413 { 1414 switch (type) 1415 { 1416 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO"; 1417 default: 1418 return NULL; 1419 } 1420 } 1421 1422 static const char * 1423 get_dynamic_type (unsigned long type) 1424 { 1425 static char buff[64]; 1426 1427 switch (type) 1428 { 1429 case DT_NULL: return "NULL"; 1430 case DT_NEEDED: return "NEEDED"; 1431 case DT_PLTRELSZ: return "PLTRELSZ"; 1432 case DT_PLTGOT: return "PLTGOT"; 1433 case DT_HASH: return "HASH"; 1434 case DT_STRTAB: return "STRTAB"; 1435 case DT_SYMTAB: return "SYMTAB"; 1436 case DT_RELA: return "RELA"; 1437 case DT_RELASZ: return "RELASZ"; 1438 case DT_RELAENT: return "RELAENT"; 1439 case DT_STRSZ: return "STRSZ"; 1440 case DT_SYMENT: return "SYMENT"; 1441 case DT_INIT: return "INIT"; 1442 case DT_FINI: return "FINI"; 1443 case DT_SONAME: return "SONAME"; 1444 case DT_RPATH: return "RPATH"; 1445 case DT_SYMBOLIC: return "SYMBOLIC"; 1446 case DT_REL: return "REL"; 1447 case DT_RELSZ: return "RELSZ"; 1448 case DT_RELENT: return "RELENT"; 1449 case DT_PLTREL: return "PLTREL"; 1450 case DT_DEBUG: return "DEBUG"; 1451 case DT_TEXTREL: return "TEXTREL"; 1452 case DT_JMPREL: return "JMPREL"; 1453 case DT_BIND_NOW: return "BIND_NOW"; 1454 case DT_INIT_ARRAY: return "INIT_ARRAY"; 1455 case DT_FINI_ARRAY: return "FINI_ARRAY"; 1456 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ"; 1457 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ"; 1458 case DT_RUNPATH: return "RUNPATH"; 1459 case DT_FLAGS: return "FLAGS"; 1460 1461 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY"; 1462 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ"; 1463 1464 case DT_CHECKSUM: return "CHECKSUM"; 1465 case DT_PLTPADSZ: return "PLTPADSZ"; 1466 case DT_MOVEENT: return "MOVEENT"; 1467 case DT_MOVESZ: return "MOVESZ"; 1468 case DT_FEATURE: return "FEATURE"; 1469 case DT_POSFLAG_1: return "POSFLAG_1"; 1470 case DT_SYMINSZ: return "SYMINSZ"; 1471 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */ 1472 1473 case DT_ADDRRNGLO: return "ADDRRNGLO"; 1474 case DT_CONFIG: return "CONFIG"; 1475 case DT_DEPAUDIT: return "DEPAUDIT"; 1476 case DT_AUDIT: return "AUDIT"; 1477 case DT_PLTPAD: return "PLTPAD"; 1478 case DT_MOVETAB: return "MOVETAB"; 1479 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */ 1480 1481 case DT_VERSYM: return "VERSYM"; 1482 1483 case DT_TLSDESC_GOT: return "TLSDESC_GOT"; 1484 case DT_TLSDESC_PLT: return "TLSDESC_PLT"; 1485 case DT_RELACOUNT: return "RELACOUNT"; 1486 case DT_RELCOUNT: return "RELCOUNT"; 1487 case DT_FLAGS_1: return "FLAGS_1"; 1488 case DT_VERDEF: return "VERDEF"; 1489 case DT_VERDEFNUM: return "VERDEFNUM"; 1490 case DT_VERNEED: return "VERNEED"; 1491 case DT_VERNEEDNUM: return "VERNEEDNUM"; 1492 1493 case DT_AUXILIARY: return "AUXILIARY"; 1494 case DT_USED: return "USED"; 1495 case DT_FILTER: return "FILTER"; 1496 1497 case DT_GNU_PRELINKED: return "GNU_PRELINKED"; 1498 case DT_GNU_CONFLICT: return "GNU_CONFLICT"; 1499 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ"; 1500 case DT_GNU_LIBLIST: return "GNU_LIBLIST"; 1501 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ"; 1502 1503 default: 1504 if ((type >= DT_LOPROC) && (type <= DT_HIPROC)) 1505 { 1506 const char *result; 1507 1508 switch (elf_header.e_machine) 1509 { 1510 case EM_MIPS: 1511 case EM_MIPS_RS3_LE: 1512 result = get_mips_dynamic_type (type); 1513 break; 1514 case EM_SPARCV9: 1515 result = get_sparc64_dynamic_type (type); 1516 break; 1517 case EM_PPC: 1518 result = get_ppc_dynamic_type (type); 1519 break; 1520 case EM_PPC64: 1521 result = get_ppc64_dynamic_type (type); 1522 break; 1523 case EM_IA_64: 1524 result = get_ia64_dynamic_type (type); 1525 break; 1526 case EM_ALPHA: 1527 result = get_alpha_dynamic_type (type); 1528 break; 1529 default: 1530 result = NULL; 1531 break; 1532 } 1533 1534 if (result != NULL) 1535 return result; 1536 1537 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type); 1538 } 1539 else if (((type >= DT_LOOS) && (type <= DT_HIOS)) 1540 || (elf_header.e_machine == EM_PARISC 1541 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS))) 1542 { 1543 const char *result; 1544 1545 switch (elf_header.e_machine) 1546 { 1547 case EM_PARISC: 1548 result = get_parisc_dynamic_type (type); 1549 break; 1550 default: 1551 result = NULL; 1552 break; 1553 } 1554 1555 if (result != NULL) 1556 return result; 1557 1558 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"), 1559 type); 1560 } 1561 else 1562 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type); 1563 1564 return buff; 1565 } 1566 } 1567 1568 static char * 1569 get_file_type (unsigned e_type) 1570 { 1571 static char buff[32]; 1572 1573 switch (e_type) 1574 { 1575 case ET_NONE: return _("NONE (None)"); 1576 case ET_REL: return _("REL (Relocatable file)"); 1577 case ET_EXEC: return _("EXEC (Executable file)"); 1578 case ET_DYN: return _("DYN (Shared object file)"); 1579 case ET_CORE: return _("CORE (Core file)"); 1580 1581 default: 1582 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC)) 1583 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type); 1584 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS)) 1585 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type); 1586 else 1587 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type); 1588 return buff; 1589 } 1590 } 1591 1592 static char * 1593 get_machine_name (unsigned e_machine) 1594 { 1595 static char buff[64]; /* XXX */ 1596 1597 switch (e_machine) 1598 { 1599 case EM_NONE: return _("None"); 1600 case EM_M32: return "WE32100"; 1601 case EM_SPARC: return "Sparc"; 1602 case EM_386: return "Intel 80386"; 1603 case EM_68K: return "MC68000"; 1604 case EM_88K: return "MC88000"; 1605 case EM_486: return "Intel 80486"; 1606 case EM_860: return "Intel 80860"; 1607 case EM_MIPS: return "MIPS R3000"; 1608 case EM_S370: return "IBM System/370"; 1609 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian"; 1610 case EM_OLD_SPARCV9: return "Sparc v9 (old)"; 1611 case EM_PARISC: return "HPPA"; 1612 case EM_PPC_OLD: return "Power PC (old)"; 1613 case EM_SPARC32PLUS: return "Sparc v8+" ; 1614 case EM_960: return "Intel 90860"; 1615 case EM_PPC: return "PowerPC"; 1616 case EM_PPC64: return "PowerPC64"; 1617 case EM_V800: return "NEC V800"; 1618 case EM_FR20: return "Fujitsu FR20"; 1619 case EM_RH32: return "TRW RH32"; 1620 case EM_MCORE: return "MCORE"; 1621 case EM_ARM: return "ARM"; 1622 case EM_OLD_ALPHA: return "Digital Alpha (old)"; 1623 case EM_SH: return "Renesas / SuperH SH"; 1624 case EM_SPARCV9: return "Sparc v9"; 1625 case EM_TRICORE: return "Siemens Tricore"; 1626 case EM_ARC: return "ARC"; 1627 case EM_H8_300: return "Renesas H8/300"; 1628 case EM_H8_300H: return "Renesas H8/300H"; 1629 case EM_H8S: return "Renesas H8S"; 1630 case EM_H8_500: return "Renesas H8/500"; 1631 case EM_IA_64: return "Intel IA-64"; 1632 case EM_MIPS_X: return "Stanford MIPS-X"; 1633 case EM_COLDFIRE: return "Motorola Coldfire"; 1634 case EM_68HC12: return "Motorola M68HC12"; 1635 case EM_ALPHA: return "Alpha"; 1636 case EM_CYGNUS_D10V: 1637 case EM_D10V: return "d10v"; 1638 case EM_CYGNUS_D30V: 1639 case EM_D30V: return "d30v"; 1640 case EM_CYGNUS_M32R: 1641 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)"; 1642 case EM_CYGNUS_V850: 1643 case EM_V850: return "NEC v850"; 1644 case EM_CYGNUS_MN10300: 1645 case EM_MN10300: return "mn10300"; 1646 case EM_CYGNUS_MN10200: 1647 case EM_MN10200: return "mn10200"; 1648 case EM_CYGNUS_FR30: 1649 case EM_FR30: return "Fujitsu FR30"; 1650 case EM_CYGNUS_FRV: return "Fujitsu FR-V"; 1651 case EM_PJ_OLD: 1652 case EM_PJ: return "picoJava"; 1653 case EM_MMA: return "Fujitsu Multimedia Accelerator"; 1654 case EM_PCP: return "Siemens PCP"; 1655 case EM_NCPU: return "Sony nCPU embedded RISC processor"; 1656 case EM_NDR1: return "Denso NDR1 microprocesspr"; 1657 case EM_STARCORE: return "Motorola Star*Core processor"; 1658 case EM_ME16: return "Toyota ME16 processor"; 1659 case EM_ST100: return "STMicroelectronics ST100 processor"; 1660 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor"; 1661 case EM_FX66: return "Siemens FX66 microcontroller"; 1662 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller"; 1663 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller"; 1664 case EM_68HC16: return "Motorola MC68HC16 Microcontroller"; 1665 case EM_68HC11: return "Motorola MC68HC11 Microcontroller"; 1666 case EM_68HC08: return "Motorola MC68HC08 Microcontroller"; 1667 case EM_68HC05: return "Motorola MC68HC05 Microcontroller"; 1668 case EM_SVX: return "Silicon Graphics SVx"; 1669 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller"; 1670 case EM_VAX: return "Digital VAX"; 1671 case EM_AVR_OLD: 1672 case EM_AVR: return "Atmel AVR 8-bit microcontroller"; 1673 case EM_CRIS: return "Axis Communications 32-bit embedded processor"; 1674 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu"; 1675 case EM_FIREPATH: return "Element 14 64-bit DSP processor"; 1676 case EM_ZSP: return "LSI Logic's 16-bit DSP processor"; 1677 case EM_MMIX: return "Donald Knuth's educational 64-bit processor"; 1678 case EM_HUANY: return "Harvard Universitys's machine-independent object format"; 1679 case EM_PRISM: return "Vitesse Prism"; 1680 case EM_X86_64: return "Advanced Micro Devices X86-64"; 1681 case EM_S390_OLD: 1682 case EM_S390: return "IBM S/390"; 1683 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core"; 1684 case EM_OPENRISC: 1685 case EM_OR32: return "OpenRISC"; 1686 case EM_CRX: return "National Semiconductor CRX microprocessor"; 1687 case EM_DLX: return "OpenDLX"; 1688 case EM_IP2K_OLD: 1689 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers"; 1690 case EM_IQ2000: return "Vitesse IQ2000"; 1691 case EM_XTENSA_OLD: 1692 case EM_XTENSA: return "Tensilica Xtensa Processor"; 1693 case EM_M32C: return "Renesas M32c"; 1694 case EM_MT: return "Morpho Techologies MT processor"; 1695 case EM_BLACKFIN: return "Analog Devices Blackfin"; 1696 case EM_NIOS32: return "Altera Nios"; 1697 case EM_ALTERA_NIOS2: return "Altera Nios II"; 1698 case EM_XC16X: return "Infineon Technologies xc16x"; 1699 default: 1700 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_machine); 1701 return buff; 1702 } 1703 } 1704 1705 static void 1706 decode_ARM_machine_flags (unsigned e_flags, char buf[]) 1707 { 1708 unsigned eabi; 1709 int unknown = 0; 1710 1711 eabi = EF_ARM_EABI_VERSION (e_flags); 1712 e_flags &= ~ EF_ARM_EABIMASK; 1713 1714 /* Handle "generic" ARM flags. */ 1715 if (e_flags & EF_ARM_RELEXEC) 1716 { 1717 strcat (buf, ", relocatable executable"); 1718 e_flags &= ~ EF_ARM_RELEXEC; 1719 } 1720 1721 if (e_flags & EF_ARM_HASENTRY) 1722 { 1723 strcat (buf, ", has entry point"); 1724 e_flags &= ~ EF_ARM_HASENTRY; 1725 } 1726 1727 /* Now handle EABI specific flags. */ 1728 switch (eabi) 1729 { 1730 default: 1731 strcat (buf, ", <unrecognized EABI>"); 1732 if (e_flags) 1733 unknown = 1; 1734 break; 1735 1736 case EF_ARM_EABI_VER1: 1737 strcat (buf, ", Version1 EABI"); 1738 while (e_flags) 1739 { 1740 unsigned flag; 1741 1742 /* Process flags one bit at a time. */ 1743 flag = e_flags & - e_flags; 1744 e_flags &= ~ flag; 1745 1746 switch (flag) 1747 { 1748 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */ 1749 strcat (buf, ", sorted symbol tables"); 1750 break; 1751 1752 default: 1753 unknown = 1; 1754 break; 1755 } 1756 } 1757 break; 1758 1759 case EF_ARM_EABI_VER2: 1760 strcat (buf, ", Version2 EABI"); 1761 while (e_flags) 1762 { 1763 unsigned flag; 1764 1765 /* Process flags one bit at a time. */ 1766 flag = e_flags & - e_flags; 1767 e_flags &= ~ flag; 1768 1769 switch (flag) 1770 { 1771 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */ 1772 strcat (buf, ", sorted symbol tables"); 1773 break; 1774 1775 case EF_ARM_DYNSYMSUSESEGIDX: 1776 strcat (buf, ", dynamic symbols use segment index"); 1777 break; 1778 1779 case EF_ARM_MAPSYMSFIRST: 1780 strcat (buf, ", mapping symbols precede others"); 1781 break; 1782 1783 default: 1784 unknown = 1; 1785 break; 1786 } 1787 } 1788 break; 1789 1790 case EF_ARM_EABI_VER3: 1791 strcat (buf, ", Version3 EABI"); 1792 break; 1793 1794 case EF_ARM_EABI_VER4: 1795 strcat (buf, ", Version4 EABI"); 1796 goto eabi; 1797 1798 case EF_ARM_EABI_VER5: 1799 strcat (buf, ", Version5 EABI"); 1800 eabi: 1801 while (e_flags) 1802 { 1803 unsigned flag; 1804 1805 /* Process flags one bit at a time. */ 1806 flag = e_flags & - e_flags; 1807 e_flags &= ~ flag; 1808 1809 switch (flag) 1810 { 1811 case EF_ARM_BE8: 1812 strcat (buf, ", BE8"); 1813 break; 1814 1815 case EF_ARM_LE8: 1816 strcat (buf, ", LE8"); 1817 break; 1818 1819 default: 1820 unknown = 1; 1821 break; 1822 } 1823 } 1824 break; 1825 1826 case EF_ARM_EABI_UNKNOWN: 1827 strcat (buf, ", GNU EABI"); 1828 while (e_flags) 1829 { 1830 unsigned flag; 1831 1832 /* Process flags one bit at a time. */ 1833 flag = e_flags & - e_flags; 1834 e_flags &= ~ flag; 1835 1836 switch (flag) 1837 { 1838 case EF_ARM_INTERWORK: 1839 strcat (buf, ", interworking enabled"); 1840 break; 1841 1842 case EF_ARM_APCS_26: 1843 strcat (buf, ", uses APCS/26"); 1844 break; 1845 1846 case EF_ARM_APCS_FLOAT: 1847 strcat (buf, ", uses APCS/float"); 1848 break; 1849 1850 case EF_ARM_PIC: 1851 strcat (buf, ", position independent"); 1852 break; 1853 1854 case EF_ARM_ALIGN8: 1855 strcat (buf, ", 8 bit structure alignment"); 1856 break; 1857 1858 case EF_ARM_NEW_ABI: 1859 strcat (buf, ", uses new ABI"); 1860 break; 1861 1862 case EF_ARM_OLD_ABI: 1863 strcat (buf, ", uses old ABI"); 1864 break; 1865 1866 case EF_ARM_SOFT_FLOAT: 1867 strcat (buf, ", software FP"); 1868 break; 1869 1870 case EF_ARM_VFP_FLOAT: 1871 strcat (buf, ", VFP"); 1872 break; 1873 1874 case EF_ARM_MAVERICK_FLOAT: 1875 strcat (buf, ", Maverick FP"); 1876 break; 1877 1878 default: 1879 unknown = 1; 1880 break; 1881 } 1882 } 1883 } 1884 1885 if (unknown) 1886 strcat (buf,", <unknown>"); 1887 } 1888 1889 static char * 1890 get_machine_flags (unsigned e_flags, unsigned e_machine) 1891 { 1892 static char buf[1024]; 1893 1894 buf[0] = '\0'; 1895 1896 if (e_flags) 1897 { 1898 switch (e_machine) 1899 { 1900 default: 1901 break; 1902 1903 case EM_ARM: 1904 decode_ARM_machine_flags (e_flags, buf); 1905 break; 1906 1907 case EM_CYGNUS_FRV: 1908 switch (e_flags & EF_FRV_CPU_MASK) 1909 { 1910 case EF_FRV_CPU_GENERIC: 1911 break; 1912 1913 default: 1914 strcat (buf, ", fr???"); 1915 break; 1916 1917 case EF_FRV_CPU_FR300: 1918 strcat (buf, ", fr300"); 1919 break; 1920 1921 case EF_FRV_CPU_FR400: 1922 strcat (buf, ", fr400"); 1923 break; 1924 case EF_FRV_CPU_FR405: 1925 strcat (buf, ", fr405"); 1926 break; 1927 1928 case EF_FRV_CPU_FR450: 1929 strcat (buf, ", fr450"); 1930 break; 1931 1932 case EF_FRV_CPU_FR500: 1933 strcat (buf, ", fr500"); 1934 break; 1935 case EF_FRV_CPU_FR550: 1936 strcat (buf, ", fr550"); 1937 break; 1938 1939 case EF_FRV_CPU_SIMPLE: 1940 strcat (buf, ", simple"); 1941 break; 1942 case EF_FRV_CPU_TOMCAT: 1943 strcat (buf, ", tomcat"); 1944 break; 1945 } 1946 break; 1947 1948 case EM_68K: 1949 if (e_flags & EF_M68K_CPU32) 1950 strcat (buf, ", cpu32"); 1951 if (e_flags & EF_M68K_M68000) 1952 strcat (buf, ", m68000"); 1953 if (e_flags & EF_M68K_ISA_MASK) 1954 { 1955 char const *isa = _("unknown"); 1956 char const *mac = _("unknown mac"); 1957 char const *additional = NULL; 1958 1959 switch (e_flags & EF_M68K_ISA_MASK) 1960 { 1961 case EF_M68K_ISA_A_NODIV: 1962 isa = "A"; 1963 additional = ", nodiv"; 1964 break; 1965 case EF_M68K_ISA_A: 1966 isa = "A"; 1967 break; 1968 case EF_M68K_ISA_A_PLUS: 1969 isa = "A+"; 1970 break; 1971 case EF_M68K_ISA_B_NOUSP: 1972 isa = "B"; 1973 additional = ", nousp"; 1974 break; 1975 case EF_M68K_ISA_B: 1976 isa = "B"; 1977 break; 1978 } 1979 strcat (buf, ", cf, isa "); 1980 strcat (buf, isa); 1981 if (additional) 1982 strcat (buf, additional); 1983 if (e_flags & EF_M68K_FLOAT) 1984 strcat (buf, ", float"); 1985 switch (e_flags & EF_M68K_MAC_MASK) 1986 { 1987 case 0: 1988 mac = NULL; 1989 break; 1990 case EF_M68K_MAC: 1991 mac = "mac"; 1992 break; 1993 case EF_M68K_EMAC: 1994 mac = "emac"; 1995 break; 1996 } 1997 if (mac) 1998 { 1999 strcat (buf, ", "); 2000 strcat (buf, mac); 2001 } 2002 } 2003 break; 2004 2005 case EM_PPC: 2006 if (e_flags & EF_PPC_EMB) 2007 strcat (buf, ", emb"); 2008 2009 if (e_flags & EF_PPC_RELOCATABLE) 2010 strcat (buf, ", relocatable"); 2011 2012 if (e_flags & EF_PPC_RELOCATABLE_LIB) 2013 strcat (buf, ", relocatable-lib"); 2014 break; 2015 2016 case EM_V850: 2017 case EM_CYGNUS_V850: 2018 switch (e_flags & EF_V850_ARCH) 2019 { 2020 case E_V850E1_ARCH: 2021 strcat (buf, ", v850e1"); 2022 break; 2023 case E_V850E_ARCH: 2024 strcat (buf, ", v850e"); 2025 break; 2026 case E_V850_ARCH: 2027 strcat (buf, ", v850"); 2028 break; 2029 default: 2030 strcat (buf, ", unknown v850 architecture variant"); 2031 break; 2032 } 2033 break; 2034 2035 case EM_M32R: 2036 case EM_CYGNUS_M32R: 2037 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH) 2038 strcat (buf, ", m32r"); 2039 2040 break; 2041 2042 case EM_MIPS: 2043 case EM_MIPS_RS3_LE: 2044 if (e_flags & EF_MIPS_NOREORDER) 2045 strcat (buf, ", noreorder"); 2046 2047 if (e_flags & EF_MIPS_PIC) 2048 strcat (buf, ", pic"); 2049 2050 if (e_flags & EF_MIPS_CPIC) 2051 strcat (buf, ", cpic"); 2052 2053 if (e_flags & EF_MIPS_UCODE) 2054 strcat (buf, ", ugen_reserved"); 2055 2056 if (e_flags & EF_MIPS_ABI2) 2057 strcat (buf, ", abi2"); 2058 2059 if (e_flags & EF_MIPS_OPTIONS_FIRST) 2060 strcat (buf, ", odk first"); 2061 2062 if (e_flags & EF_MIPS_32BITMODE) 2063 strcat (buf, ", 32bitmode"); 2064 2065 switch ((e_flags & EF_MIPS_MACH)) 2066 { 2067 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break; 2068 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break; 2069 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break; 2070 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break; 2071 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break; 2072 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break; 2073 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break; 2074 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break; 2075 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break; 2076 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break; 2077 case 0: 2078 /* We simply ignore the field in this case to avoid confusion: 2079 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU 2080 extension. */ 2081 break; 2082 default: strcat (buf, ", unknown CPU"); break; 2083 } 2084 2085 switch ((e_flags & EF_MIPS_ABI)) 2086 { 2087 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break; 2088 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break; 2089 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break; 2090 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break; 2091 case 0: 2092 /* We simply ignore the field in this case to avoid confusion: 2093 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension. 2094 This means it is likely to be an o32 file, but not for 2095 sure. */ 2096 break; 2097 default: strcat (buf, ", unknown ABI"); break; 2098 } 2099 2100 if (e_flags & EF_MIPS_ARCH_ASE_MDMX) 2101 strcat (buf, ", mdmx"); 2102 2103 if (e_flags & EF_MIPS_ARCH_ASE_M16) 2104 strcat (buf, ", mips16"); 2105 2106 switch ((e_flags & EF_MIPS_ARCH)) 2107 { 2108 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break; 2109 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break; 2110 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break; 2111 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break; 2112 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break; 2113 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break; 2114 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break; 2115 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break; 2116 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break; 2117 default: strcat (buf, ", unknown ISA"); break; 2118 } 2119 2120 break; 2121 2122 case EM_SH: 2123 switch ((e_flags & EF_SH_MACH_MASK)) 2124 { 2125 case EF_SH1: strcat (buf, ", sh1"); break; 2126 case EF_SH2: strcat (buf, ", sh2"); break; 2127 case EF_SH3: strcat (buf, ", sh3"); break; 2128 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break; 2129 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break; 2130 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break; 2131 case EF_SH3E: strcat (buf, ", sh3e"); break; 2132 case EF_SH4: strcat (buf, ", sh4"); break; 2133 case EF_SH5: strcat (buf, ", sh5"); break; 2134 case EF_SH2E: strcat (buf, ", sh2e"); break; 2135 case EF_SH4A: strcat (buf, ", sh4a"); break; 2136 case EF_SH2A: strcat (buf, ", sh2a"); break; 2137 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break; 2138 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break; 2139 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break; 2140 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break; 2141 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break; 2142 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break; 2143 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break; 2144 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break; 2145 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break; 2146 default: strcat (buf, ", unknown ISA"); break; 2147 } 2148 2149 break; 2150 2151 case EM_SPARCV9: 2152 if (e_flags & EF_SPARC_32PLUS) 2153 strcat (buf, ", v8+"); 2154 2155 if (e_flags & EF_SPARC_SUN_US1) 2156 strcat (buf, ", ultrasparcI"); 2157 2158 if (e_flags & EF_SPARC_SUN_US3) 2159 strcat (buf, ", ultrasparcIII"); 2160 2161 if (e_flags & EF_SPARC_HAL_R1) 2162 strcat (buf, ", halr1"); 2163 2164 if (e_flags & EF_SPARC_LEDATA) 2165 strcat (buf, ", ledata"); 2166 2167 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO) 2168 strcat (buf, ", tso"); 2169 2170 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO) 2171 strcat (buf, ", pso"); 2172 2173 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO) 2174 strcat (buf, ", rmo"); 2175 break; 2176 2177 case EM_PARISC: 2178 switch (e_flags & EF_PARISC_ARCH) 2179 { 2180 case EFA_PARISC_1_0: 2181 strcpy (buf, ", PA-RISC 1.0"); 2182 break; 2183 case EFA_PARISC_1_1: 2184 strcpy (buf, ", PA-RISC 1.1"); 2185 break; 2186 case EFA_PARISC_2_0: 2187 strcpy (buf, ", PA-RISC 2.0"); 2188 break; 2189 default: 2190 break; 2191 } 2192 if (e_flags & EF_PARISC_TRAPNIL) 2193 strcat (buf, ", trapnil"); 2194 if (e_flags & EF_PARISC_EXT) 2195 strcat (buf, ", ext"); 2196 if (e_flags & EF_PARISC_LSB) 2197 strcat (buf, ", lsb"); 2198 if (e_flags & EF_PARISC_WIDE) 2199 strcat (buf, ", wide"); 2200 if (e_flags & EF_PARISC_NO_KABP) 2201 strcat (buf, ", no kabp"); 2202 if (e_flags & EF_PARISC_LAZYSWAP) 2203 strcat (buf, ", lazyswap"); 2204 break; 2205 2206 case EM_PJ: 2207 case EM_PJ_OLD: 2208 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS) 2209 strcat (buf, ", new calling convention"); 2210 2211 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS) 2212 strcat (buf, ", gnu calling convention"); 2213 break; 2214 2215 case EM_IA_64: 2216 if ((e_flags & EF_IA_64_ABI64)) 2217 strcat (buf, ", 64-bit"); 2218 else 2219 strcat (buf, ", 32-bit"); 2220 if ((e_flags & EF_IA_64_REDUCEDFP)) 2221 strcat (buf, ", reduced fp model"); 2222 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP)) 2223 strcat (buf, ", no function descriptors, constant gp"); 2224 else if ((e_flags & EF_IA_64_CONS_GP)) 2225 strcat (buf, ", constant gp"); 2226 if ((e_flags & EF_IA_64_ABSOLUTE)) 2227 strcat (buf, ", absolute"); 2228 break; 2229 2230 case EM_VAX: 2231 if ((e_flags & EF_VAX_NONPIC)) 2232 strcat (buf, ", non-PIC"); 2233 if ((e_flags & EF_VAX_DFLOAT)) 2234 strcat (buf, ", D-Float"); 2235 if ((e_flags & EF_VAX_GFLOAT)) 2236 strcat (buf, ", G-Float"); 2237 break; 2238 } 2239 } 2240 2241 return buf; 2242 } 2243 2244 static const char * 2245 get_osabi_name (unsigned int osabi) 2246 { 2247 static char buff[32]; 2248 2249 switch (osabi) 2250 { 2251 case ELFOSABI_NONE: return "UNIX - System V"; 2252 case ELFOSABI_HPUX: return "UNIX - HP-UX"; 2253 case ELFOSABI_NETBSD: return "UNIX - NetBSD"; 2254 case ELFOSABI_LINUX: return "UNIX - Linux"; 2255 case ELFOSABI_HURD: return "GNU/Hurd"; 2256 case ELFOSABI_SOLARIS: return "UNIX - Solaris"; 2257 case ELFOSABI_AIX: return "UNIX - AIX"; 2258 case ELFOSABI_IRIX: return "UNIX - IRIX"; 2259 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD"; 2260 case ELFOSABI_TRU64: return "UNIX - TRU64"; 2261 case ELFOSABI_MODESTO: return "Novell - Modesto"; 2262 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD"; 2263 case ELFOSABI_OPENVMS: return "VMS - OpenVMS"; 2264 case ELFOSABI_NSK: return "HP - Non-Stop Kernel"; 2265 case ELFOSABI_AROS: return "Amiga Research OS"; 2266 case ELFOSABI_STANDALONE: return _("Standalone App"); 2267 case ELFOSABI_ARM: return "ARM"; 2268 default: 2269 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi); 2270 return buff; 2271 } 2272 } 2273 2274 static const char * 2275 get_arm_segment_type (unsigned long type) 2276 { 2277 switch (type) 2278 { 2279 case PT_ARM_EXIDX: 2280 return "EXIDX"; 2281 default: 2282 break; 2283 } 2284 2285 return NULL; 2286 } 2287 2288 static const char * 2289 get_mips_segment_type (unsigned long type) 2290 { 2291 switch (type) 2292 { 2293 case PT_MIPS_REGINFO: 2294 return "REGINFO"; 2295 case PT_MIPS_RTPROC: 2296 return "RTPROC"; 2297 case PT_MIPS_OPTIONS: 2298 return "OPTIONS"; 2299 default: 2300 break; 2301 } 2302 2303 return NULL; 2304 } 2305 2306 static const char * 2307 get_parisc_segment_type (unsigned long type) 2308 { 2309 switch (type) 2310 { 2311 case PT_HP_TLS: return "HP_TLS"; 2312 case PT_HP_CORE_NONE: return "HP_CORE_NONE"; 2313 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION"; 2314 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL"; 2315 case PT_HP_CORE_COMM: return "HP_CORE_COMM"; 2316 case PT_HP_CORE_PROC: return "HP_CORE_PROC"; 2317 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE"; 2318 case PT_HP_CORE_STACK: return "HP_CORE_STACK"; 2319 case PT_HP_CORE_SHM: return "HP_CORE_SHM"; 2320 case PT_HP_CORE_MMF: return "HP_CORE_MMF"; 2321 case PT_HP_PARALLEL: return "HP_PARALLEL"; 2322 case PT_HP_FASTBIND: return "HP_FASTBIND"; 2323 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT"; 2324 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT"; 2325 case PT_HP_STACK: return "HP_STACK"; 2326 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME"; 2327 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT"; 2328 case PT_PARISC_UNWIND: return "PARISC_UNWIND"; 2329 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER"; 2330 default: 2331 break; 2332 } 2333 2334 return NULL; 2335 } 2336 2337 static const char * 2338 get_ia64_segment_type (unsigned long type) 2339 { 2340 switch (type) 2341 { 2342 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT"; 2343 case PT_IA_64_UNWIND: return "IA_64_UNWIND"; 2344 case PT_HP_TLS: return "HP_TLS"; 2345 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT"; 2346 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT"; 2347 case PT_IA_64_HP_STACK: return "HP_STACK"; 2348 default: 2349 break; 2350 } 2351 2352 return NULL; 2353 } 2354 2355 static const char * 2356 get_segment_type (unsigned long p_type) 2357 { 2358 static char buff[32]; 2359 2360 switch (p_type) 2361 { 2362 case PT_NULL: return "NULL"; 2363 case PT_LOAD: return "LOAD"; 2364 case PT_DYNAMIC: return "DYNAMIC"; 2365 case PT_INTERP: return "INTERP"; 2366 case PT_NOTE: return "NOTE"; 2367 case PT_SHLIB: return "SHLIB"; 2368 case PT_PHDR: return "PHDR"; 2369 case PT_TLS: return "TLS"; 2370 2371 case PT_GNU_EH_FRAME: 2372 return "GNU_EH_FRAME"; 2373 case PT_GNU_STACK: return "GNU_STACK"; 2374 case PT_GNU_RELRO: return "GNU_RELRO"; 2375 2376 default: 2377 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC)) 2378 { 2379 const char *result; 2380 2381 switch (elf_header.e_machine) 2382 { 2383 case EM_ARM: 2384 result = get_arm_segment_type (p_type); 2385 break; 2386 case EM_MIPS: 2387 case EM_MIPS_RS3_LE: 2388 result = get_mips_segment_type (p_type); 2389 break; 2390 case EM_PARISC: 2391 result = get_parisc_segment_type (p_type); 2392 break; 2393 case EM_IA_64: 2394 result = get_ia64_segment_type (p_type); 2395 break; 2396 default: 2397 result = NULL; 2398 break; 2399 } 2400 2401 if (result != NULL) 2402 return result; 2403 2404 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC); 2405 } 2406 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS)) 2407 { 2408 const char *result; 2409 2410 switch (elf_header.e_machine) 2411 { 2412 case EM_PARISC: 2413 result = get_parisc_segment_type (p_type); 2414 break; 2415 case EM_IA_64: 2416 result = get_ia64_segment_type (p_type); 2417 break; 2418 default: 2419 result = NULL; 2420 break; 2421 } 2422 2423 if (result != NULL) 2424 return result; 2425 2426 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS); 2427 } 2428 else 2429 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type); 2430 2431 return buff; 2432 } 2433 } 2434 2435 static const char * 2436 get_mips_section_type_name (unsigned int sh_type) 2437 { 2438 switch (sh_type) 2439 { 2440 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST"; 2441 case SHT_MIPS_MSYM: return "MIPS_MSYM"; 2442 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT"; 2443 case SHT_MIPS_GPTAB: return "MIPS_GPTAB"; 2444 case SHT_MIPS_UCODE: return "MIPS_UCODE"; 2445 case SHT_MIPS_DEBUG: return "MIPS_DEBUG"; 2446 case SHT_MIPS_REGINFO: return "MIPS_REGINFO"; 2447 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE"; 2448 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM"; 2449 case SHT_MIPS_RELD: return "MIPS_RELD"; 2450 case SHT_MIPS_IFACE: return "MIPS_IFACE"; 2451 case SHT_MIPS_CONTENT: return "MIPS_CONTENT"; 2452 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS"; 2453 case SHT_MIPS_SHDR: return "MIPS_SHDR"; 2454 case SHT_MIPS_FDESC: return "MIPS_FDESC"; 2455 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM"; 2456 case SHT_MIPS_DENSE: return "MIPS_DENSE"; 2457 case SHT_MIPS_PDESC: return "MIPS_PDESC"; 2458 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM"; 2459 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM"; 2460 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM"; 2461 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR"; 2462 case SHT_MIPS_LINE: return "MIPS_LINE"; 2463 case SHT_MIPS_RFDESC: return "MIPS_RFDESC"; 2464 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM"; 2465 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST"; 2466 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS"; 2467 case SHT_MIPS_DWARF: return "MIPS_DWARF"; 2468 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL"; 2469 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB"; 2470 case SHT_MIPS_EVENTS: return "MIPS_EVENTS"; 2471 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE"; 2472 case SHT_MIPS_PIXIE: return "MIPS_PIXIE"; 2473 case SHT_MIPS_XLATE: return "MIPS_XLATE"; 2474 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG"; 2475 case SHT_MIPS_WHIRL: return "MIPS_WHIRL"; 2476 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION"; 2477 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD"; 2478 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION"; 2479 default: 2480 break; 2481 } 2482 return NULL; 2483 } 2484 2485 static const char * 2486 get_parisc_section_type_name (unsigned int sh_type) 2487 { 2488 switch (sh_type) 2489 { 2490 case SHT_PARISC_EXT: return "PARISC_EXT"; 2491 case SHT_PARISC_UNWIND: return "PARISC_UNWIND"; 2492 case SHT_PARISC_DOC: return "PARISC_DOC"; 2493 case SHT_PARISC_ANNOT: return "PARISC_ANNOT"; 2494 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN"; 2495 case SHT_PARISC_STUBS: return "PARISC_STUBS"; 2496 case SHT_PARISC_DLKM: return "PARISC_DLKM"; 2497 default: 2498 break; 2499 } 2500 return NULL; 2501 } 2502 2503 static const char * 2504 get_ia64_section_type_name (unsigned int sh_type) 2505 { 2506 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */ 2507 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG) 2508 return get_osabi_name ((sh_type & 0x00FF0000) >> 16); 2509 2510 switch (sh_type) 2511 { 2512 case SHT_IA_64_EXT: return "IA_64_EXT"; 2513 case SHT_IA_64_UNWIND: return "IA_64_UNWIND"; 2514 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT"; 2515 default: 2516 break; 2517 } 2518 return NULL; 2519 } 2520 2521 static const char * 2522 get_x86_64_section_type_name (unsigned int sh_type) 2523 { 2524 switch (sh_type) 2525 { 2526 case SHT_X86_64_UNWIND: return "X86_64_UNWIND"; 2527 default: 2528 break; 2529 } 2530 return NULL; 2531 } 2532 2533 static const char * 2534 get_arm_section_type_name (unsigned int sh_type) 2535 { 2536 switch (sh_type) 2537 { 2538 case SHT_ARM_EXIDX: 2539 return "ARM_EXIDX"; 2540 case SHT_ARM_PREEMPTMAP: 2541 return "ARM_PREEMPTMAP"; 2542 case SHT_ARM_ATTRIBUTES: 2543 return "ARM_ATTRIBUTES"; 2544 default: 2545 break; 2546 } 2547 return NULL; 2548 } 2549 2550 static const char * 2551 get_section_type_name (unsigned int sh_type) 2552 { 2553 static char buff[32]; 2554 2555 switch (sh_type) 2556 { 2557 case SHT_NULL: return "NULL"; 2558 case SHT_PROGBITS: return "PROGBITS"; 2559 case SHT_SYMTAB: return "SYMTAB"; 2560 case SHT_STRTAB: return "STRTAB"; 2561 case SHT_RELA: return "RELA"; 2562 case SHT_HASH: return "HASH"; 2563 case SHT_DYNAMIC: return "DYNAMIC"; 2564 case SHT_NOTE: return "NOTE"; 2565 case SHT_NOBITS: return "NOBITS"; 2566 case SHT_REL: return "REL"; 2567 case SHT_SHLIB: return "SHLIB"; 2568 case SHT_DYNSYM: return "DYNSYM"; 2569 case SHT_INIT_ARRAY: return "INIT_ARRAY"; 2570 case SHT_FINI_ARRAY: return "FINI_ARRAY"; 2571 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY"; 2572 case SHT_GROUP: return "GROUP"; 2573 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES"; 2574 case SHT_GNU_verdef: return "VERDEF"; 2575 case SHT_GNU_verneed: return "VERNEED"; 2576 case SHT_GNU_versym: return "VERSYM"; 2577 case 0x6ffffff0: return "VERSYM"; 2578 case 0x6ffffffc: return "VERDEF"; 2579 case 0x7ffffffd: return "AUXILIARY"; 2580 case 0x7fffffff: return "FILTER"; 2581 case SHT_GNU_LIBLIST: return "GNU_LIBLIST"; 2582 2583 default: 2584 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC)) 2585 { 2586 const char *result; 2587 2588 switch (elf_header.e_machine) 2589 { 2590 case EM_MIPS: 2591 case EM_MIPS_RS3_LE: 2592 result = get_mips_section_type_name (sh_type); 2593 break; 2594 case EM_PARISC: 2595 result = get_parisc_section_type_name (sh_type); 2596 break; 2597 case EM_IA_64: 2598 result = get_ia64_section_type_name (sh_type); 2599 break; 2600 case EM_X86_64: 2601 result = get_x86_64_section_type_name (sh_type); 2602 break; 2603 case EM_ARM: 2604 result = get_arm_section_type_name (sh_type); 2605 break; 2606 default: 2607 result = NULL; 2608 break; 2609 } 2610 2611 if (result != NULL) 2612 return result; 2613 2614 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC); 2615 } 2616 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS)) 2617 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS); 2618 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER)) 2619 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER); 2620 else 2621 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type); 2622 2623 return buff; 2624 } 2625 } 2626 2627 #define OPTION_DEBUG_DUMP 512 2628 2629 static struct option options[] = 2630 { 2631 {"all", no_argument, 0, 'a'}, 2632 {"file-header", no_argument, 0, 'h'}, 2633 {"program-headers", no_argument, 0, 'l'}, 2634 {"headers", no_argument, 0, 'e'}, 2635 {"histogram", no_argument, 0, 'I'}, 2636 {"segments", no_argument, 0, 'l'}, 2637 {"sections", no_argument, 0, 'S'}, 2638 {"section-headers", no_argument, 0, 'S'}, 2639 {"section-groups", no_argument, 0, 'g'}, 2640 {"section-details", no_argument, 0, 't'}, 2641 {"full-section-name",no_argument, 0, 'N'}, 2642 {"symbols", no_argument, 0, 's'}, 2643 {"syms", no_argument, 0, 's'}, 2644 {"relocs", no_argument, 0, 'r'}, 2645 {"notes", no_argument, 0, 'n'}, 2646 {"dynamic", no_argument, 0, 'd'}, 2647 {"arch-specific", no_argument, 0, 'A'}, 2648 {"version-info", no_argument, 0, 'V'}, 2649 {"use-dynamic", no_argument, 0, 'D'}, 2650 {"hex-dump", required_argument, 0, 'x'}, 2651 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP}, 2652 {"unwind", no_argument, 0, 'u'}, 2653 #ifdef SUPPORT_DISASSEMBLY 2654 {"instruction-dump", required_argument, 0, 'i'}, 2655 #endif 2656 2657 {"version", no_argument, 0, 'v'}, 2658 {"wide", no_argument, 0, 'W'}, 2659 {"help", no_argument, 0, 'H'}, 2660 {0, no_argument, 0, 0} 2661 }; 2662 2663 static void 2664 usage (void) 2665 { 2666 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n")); 2667 fprintf (stdout, _(" Display information about the contents of ELF format files\n")); 2668 fprintf (stdout, _(" Options are:\n\ 2669 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\ 2670 -h --file-header Display the ELF file header\n\ 2671 -l --program-headers Display the program headers\n\ 2672 --segments An alias for --program-headers\n\ 2673 -S --section-headers Display the sections' header\n\ 2674 --sections An alias for --section-headers\n\ 2675 -g --section-groups Display the section groups\n\ 2676 -t --section-details Display the section details\n\ 2677 -e --headers Equivalent to: -h -l -S\n\ 2678 -s --syms Display the symbol table\n\ 2679 --symbols An alias for --syms\n\ 2680 -n --notes Display the core notes (if present)\n\ 2681 -r --relocs Display the relocations (if present)\n\ 2682 -u --unwind Display the unwind info (if present)\n\ 2683 -d --dynamic Display the dynamic section (if present)\n\ 2684 -V --version-info Display the version sections (if present)\n\ 2685 -A --arch-specific Display architecture specific information (if any).\n\ 2686 -D --use-dynamic Use the dynamic section info when displaying symbols\n\ 2687 -x --hex-dump=<number> Dump the contents of section <number>\n\ 2688 -w[liaprmfFsoR] or\n\ 2689 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\ 2690 Display the contents of DWARF2 debug sections\n")); 2691 #ifdef SUPPORT_DISASSEMBLY 2692 fprintf (stdout, _("\ 2693 -i --instruction-dump=<number>\n\ 2694 Disassemble the contents of section <number>\n")); 2695 #endif 2696 fprintf (stdout, _("\ 2697 -I --histogram Display histogram of bucket list lengths\n\ 2698 -W --wide Allow output width to exceed 80 characters\n\ 2699 @<file> Read options from <file>\n\ 2700 -H --help Display this information\n\ 2701 -v --version Display the version number of readelf\n")); 2702 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO); 2703 2704 exit (0); 2705 } 2706 2707 /* Record the fact that the user wants the contents of section number 2708 SECTION to be displayed using the method(s) encoded as flags bits 2709 in TYPE. Note, TYPE can be zero if we are creating the array for 2710 the first time. */ 2711 2712 static void 2713 request_dump (unsigned int section, int type) 2714 { 2715 if (section >= num_dump_sects) 2716 { 2717 char *new_dump_sects; 2718 2719 new_dump_sects = calloc (section + 1, 1); 2720 2721 if (new_dump_sects == NULL) 2722 error (_("Out of memory allocating dump request table.")); 2723 else 2724 { 2725 /* Copy current flag settings. */ 2726 memcpy (new_dump_sects, dump_sects, num_dump_sects); 2727 2728 free (dump_sects); 2729 2730 dump_sects = new_dump_sects; 2731 num_dump_sects = section + 1; 2732 } 2733 } 2734 2735 if (dump_sects) 2736 dump_sects[section] |= type; 2737 2738 return; 2739 } 2740 2741 /* Request a dump by section name. */ 2742 2743 static void 2744 request_dump_byname (const char *section, int type) 2745 { 2746 struct dump_list_entry *new_request; 2747 2748 new_request = malloc (sizeof (struct dump_list_entry)); 2749 if (!new_request) 2750 error (_("Out of memory allocating dump request table.")); 2751 2752 new_request->name = strdup (section); 2753 if (!new_request->name) 2754 error (_("Out of memory allocating dump request table.")); 2755 2756 new_request->type = type; 2757 2758 new_request->next = dump_sects_byname; 2759 dump_sects_byname = new_request; 2760 } 2761 2762 static void 2763 parse_args (int argc, char **argv) 2764 { 2765 int c; 2766 2767 if (argc < 2) 2768 usage (); 2769 2770 while ((c = getopt_long 2771 (argc, argv, "ersuahnldSDAINtgw::x:i:vVWH", options, NULL)) != EOF) 2772 { 2773 char *cp; 2774 int section; 2775 2776 switch (c) 2777 { 2778 case 0: 2779 /* Long options. */ 2780 break; 2781 case 'H': 2782 usage (); 2783 break; 2784 2785 case 'a': 2786 do_syms++; 2787 do_reloc++; 2788 do_unwind++; 2789 do_dynamic++; 2790 do_header++; 2791 do_sections++; 2792 do_section_groups++; 2793 do_segments++; 2794 do_version++; 2795 do_histogram++; 2796 do_arch++; 2797 do_notes++; 2798 break; 2799 case 'g': 2800 do_section_groups++; 2801 break; 2802 case 't': 2803 case 'N': 2804 do_sections++; 2805 do_section_details++; 2806 break; 2807 case 'e': 2808 do_header++; 2809 do_sections++; 2810 do_segments++; 2811 break; 2812 case 'A': 2813 do_arch++; 2814 break; 2815 case 'D': 2816 do_using_dynamic++; 2817 break; 2818 case 'r': 2819 do_reloc++; 2820 break; 2821 case 'u': 2822 do_unwind++; 2823 break; 2824 case 'h': 2825 do_header++; 2826 break; 2827 case 'l': 2828 do_segments++; 2829 break; 2830 case 's': 2831 do_syms++; 2832 break; 2833 case 'S': 2834 do_sections++; 2835 break; 2836 case 'd': 2837 do_dynamic++; 2838 break; 2839 case 'I': 2840 do_histogram++; 2841 break; 2842 case 'n': 2843 do_notes++; 2844 break; 2845 case 'x': 2846 do_dump++; 2847 section = strtoul (optarg, & cp, 0); 2848 if (! *cp && section >= 0) 2849 request_dump (section, HEX_DUMP); 2850 else 2851 request_dump_byname (optarg, HEX_DUMP); 2852 break; 2853 case 'w': 2854 do_dump++; 2855 if (optarg == 0) 2856 do_debugging = 1; 2857 else 2858 { 2859 unsigned int index = 0; 2860 2861 do_debugging = 0; 2862 2863 while (optarg[index]) 2864 switch (optarg[index++]) 2865 { 2866 case 'i': 2867 case 'I': 2868 do_debug_info = 1; 2869 break; 2870 2871 case 'a': 2872 case 'A': 2873 do_debug_abbrevs = 1; 2874 break; 2875 2876 case 'l': 2877 case 'L': 2878 do_debug_lines = 1; 2879 break; 2880 2881 case 'p': 2882 case 'P': 2883 do_debug_pubnames = 1; 2884 break; 2885 2886 case 'r': 2887 do_debug_aranges = 1; 2888 break; 2889 2890 case 'R': 2891 do_debug_ranges = 1; 2892 break; 2893 2894 case 'F': 2895 do_debug_frames_interp = 1; 2896 case 'f': 2897 do_debug_frames = 1; 2898 break; 2899 2900 case 'm': 2901 case 'M': 2902 do_debug_macinfo = 1; 2903 break; 2904 2905 case 's': 2906 case 'S': 2907 do_debug_str = 1; 2908 break; 2909 2910 case 'o': 2911 case 'O': 2912 do_debug_loc = 1; 2913 break; 2914 2915 default: 2916 warn (_("Unrecognized debug option '%s'\n"), optarg); 2917 break; 2918 } 2919 } 2920 break; 2921 case OPTION_DEBUG_DUMP: 2922 do_dump++; 2923 if (optarg == 0) 2924 do_debugging = 1; 2925 else 2926 { 2927 typedef struct 2928 { 2929 const char * option; 2930 int * variable; 2931 } 2932 debug_dump_long_opts; 2933 2934 debug_dump_long_opts opts_table [] = 2935 { 2936 /* Please keep this table alpha- sorted. */ 2937 { "Ranges", & do_debug_ranges }, 2938 { "abbrev", & do_debug_abbrevs }, 2939 { "aranges", & do_debug_aranges }, 2940 { "frames", & do_debug_frames }, 2941 { "frames-interp", & do_debug_frames_interp }, 2942 { "info", & do_debug_info }, 2943 { "line", & do_debug_lines }, 2944 { "loc", & do_debug_loc }, 2945 { "macro", & do_debug_macinfo }, 2946 { "pubnames", & do_debug_pubnames }, 2947 /* This entry is for compatability 2948 with earlier versions of readelf. */ 2949 { "ranges", & do_debug_aranges }, 2950 { "str", & do_debug_str }, 2951 { NULL, NULL } 2952 }; 2953 2954 const char *p; 2955 2956 do_debugging = 0; 2957 2958 p = optarg; 2959 while (*p) 2960 { 2961 debug_dump_long_opts * entry; 2962 2963 for (entry = opts_table; entry->option; entry++) 2964 { 2965 size_t len = strlen (entry->option); 2966 2967 if (strneq (p, entry->option, len) 2968 && (p[len] == ',' || p[len] == '\0')) 2969 { 2970 * entry->variable = 1; 2971 2972 /* The --debug-dump=frames-interp option also 2973 enables the --debug-dump=frames option. */ 2974 if (do_debug_frames_interp) 2975 do_debug_frames = 1; 2976 2977 p += len; 2978 break; 2979 } 2980 } 2981 2982 if (entry->option == NULL) 2983 { 2984 warn (_("Unrecognized debug option '%s'\n"), p); 2985 p = strchr (p, ','); 2986 if (p == NULL) 2987 break; 2988 } 2989 2990 if (*p == ',') 2991 p++; 2992 } 2993 } 2994 break; 2995 #ifdef SUPPORT_DISASSEMBLY 2996 case 'i': 2997 do_dump++; 2998 section = strtoul (optarg, & cp, 0); 2999 if (! *cp && section >= 0) 3000 { 3001 request_dump (section, DISASS_DUMP); 3002 break; 3003 } 3004 goto oops; 3005 #endif 3006 case 'v': 3007 print_version (program_name); 3008 break; 3009 case 'V': 3010 do_version++; 3011 break; 3012 case 'W': 3013 do_wide++; 3014 break; 3015 default: 3016 #ifdef SUPPORT_DISASSEMBLY 3017 oops: 3018 #endif 3019 /* xgettext:c-format */ 3020 error (_("Invalid option '-%c'\n"), c); 3021 /* Drop through. */ 3022 case '?': 3023 usage (); 3024 } 3025 } 3026 3027 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections 3028 && !do_segments && !do_header && !do_dump && !do_version 3029 && !do_histogram && !do_debugging && !do_arch && !do_notes 3030 && !do_section_groups) 3031 usage (); 3032 else if (argc < 3) 3033 { 3034 warn (_("Nothing to do.\n")); 3035 usage (); 3036 } 3037 } 3038 3039 static const char * 3040 get_elf_class (unsigned int elf_class) 3041 { 3042 static char buff[32]; 3043 3044 switch (elf_class) 3045 { 3046 case ELFCLASSNONE: return _("none"); 3047 case ELFCLASS32: return "ELF32"; 3048 case ELFCLASS64: return "ELF64"; 3049 default: 3050 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class); 3051 return buff; 3052 } 3053 } 3054 3055 static const char * 3056 get_data_encoding (unsigned int encoding) 3057 { 3058 static char buff[32]; 3059 3060 switch (encoding) 3061 { 3062 case ELFDATANONE: return _("none"); 3063 case ELFDATA2LSB: return _("2's complement, little endian"); 3064 case ELFDATA2MSB: return _("2's complement, big endian"); 3065 default: 3066 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding); 3067 return buff; 3068 } 3069 } 3070 3071 /* Decode the data held in 'elf_header'. */ 3072 3073 static int 3074 process_file_header (void) 3075 { 3076 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0 3077 || elf_header.e_ident[EI_MAG1] != ELFMAG1 3078 || elf_header.e_ident[EI_MAG2] != ELFMAG2 3079 || elf_header.e_ident[EI_MAG3] != ELFMAG3) 3080 { 3081 error 3082 (_("Not an ELF file - it has the wrong magic bytes at the start\n")); 3083 return 0; 3084 } 3085 3086 if (do_header) 3087 { 3088 int i; 3089 3090 printf (_("ELF Header:\n")); 3091 printf (_(" Magic: ")); 3092 for (i = 0; i < EI_NIDENT; i++) 3093 printf ("%2.2x ", elf_header.e_ident[i]); 3094 printf ("\n"); 3095 printf (_(" Class: %s\n"), 3096 get_elf_class (elf_header.e_ident[EI_CLASS])); 3097 printf (_(" Data: %s\n"), 3098 get_data_encoding (elf_header.e_ident[EI_DATA])); 3099 printf (_(" Version: %d %s\n"), 3100 elf_header.e_ident[EI_VERSION], 3101 (elf_header.e_ident[EI_VERSION] == EV_CURRENT 3102 ? "(current)" 3103 : (elf_header.e_ident[EI_VERSION] != EV_NONE 3104 ? "<unknown: %lx>" 3105 : ""))); 3106 printf (_(" OS/ABI: %s\n"), 3107 get_osabi_name (elf_header.e_ident[EI_OSABI])); 3108 printf (_(" ABI Version: %d\n"), 3109 elf_header.e_ident[EI_ABIVERSION]); 3110 printf (_(" Type: %s\n"), 3111 get_file_type (elf_header.e_type)); 3112 printf (_(" Machine: %s\n"), 3113 get_machine_name (elf_header.e_machine)); 3114 printf (_(" Version: 0x%lx\n"), 3115 (unsigned long) elf_header.e_version); 3116 3117 printf (_(" Entry point address: ")); 3118 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX); 3119 printf (_("\n Start of program headers: ")); 3120 print_vma ((bfd_vma) elf_header.e_phoff, DEC); 3121 printf (_(" (bytes into file)\n Start of section headers: ")); 3122 print_vma ((bfd_vma) elf_header.e_shoff, DEC); 3123 printf (_(" (bytes into file)\n")); 3124 3125 printf (_(" Flags: 0x%lx%s\n"), 3126 (unsigned long) elf_header.e_flags, 3127 get_machine_flags (elf_header.e_flags, elf_header.e_machine)); 3128 printf (_(" Size of this header: %ld (bytes)\n"), 3129 (long) elf_header.e_ehsize); 3130 printf (_(" Size of program headers: %ld (bytes)\n"), 3131 (long) elf_header.e_phentsize); 3132 printf (_(" Number of program headers: %ld\n"), 3133 (long) elf_header.e_phnum); 3134 printf (_(" Size of section headers: %ld (bytes)\n"), 3135 (long) elf_header.e_shentsize); 3136 printf (_(" Number of section headers: %ld"), 3137 (long) elf_header.e_shnum); 3138 if (section_headers != NULL && elf_header.e_shnum == 0) 3139 printf (" (%ld)", (long) section_headers[0].sh_size); 3140 putc ('\n', stdout); 3141 printf (_(" Section header string table index: %ld"), 3142 (long) elf_header.e_shstrndx); 3143 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX) 3144 printf (" (%ld)", (long) section_headers[0].sh_link); 3145 putc ('\n', stdout); 3146 } 3147 3148 if (section_headers != NULL) 3149 { 3150 if (elf_header.e_shnum == 0) 3151 elf_header.e_shnum = section_headers[0].sh_size; 3152 if (elf_header.e_shstrndx == SHN_XINDEX) 3153 elf_header.e_shstrndx = section_headers[0].sh_link; 3154 free (section_headers); 3155 section_headers = NULL; 3156 } 3157 3158 return 1; 3159 } 3160 3161 3162 static int 3163 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers) 3164 { 3165 Elf32_External_Phdr *phdrs; 3166 Elf32_External_Phdr *external; 3167 Elf_Internal_Phdr *internal; 3168 unsigned int i; 3169 3170 phdrs = get_data (NULL, file, elf_header.e_phoff, 3171 elf_header.e_phentsize, elf_header.e_phnum, 3172 _("program headers")); 3173 if (!phdrs) 3174 return 0; 3175 3176 for (i = 0, internal = program_headers, external = phdrs; 3177 i < elf_header.e_phnum; 3178 i++, internal++, external++) 3179 { 3180 internal->p_type = BYTE_GET (external->p_type); 3181 internal->p_offset = BYTE_GET (external->p_offset); 3182 internal->p_vaddr = BYTE_GET (external->p_vaddr); 3183 internal->p_paddr = BYTE_GET (external->p_paddr); 3184 internal->p_filesz = BYTE_GET (external->p_filesz); 3185 internal->p_memsz = BYTE_GET (external->p_memsz); 3186 internal->p_flags = BYTE_GET (external->p_flags); 3187 internal->p_align = BYTE_GET (external->p_align); 3188 } 3189 3190 free (phdrs); 3191 3192 return 1; 3193 } 3194 3195 static int 3196 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers) 3197 { 3198 Elf64_External_Phdr *phdrs; 3199 Elf64_External_Phdr *external; 3200 Elf_Internal_Phdr *internal; 3201 unsigned int i; 3202 3203 phdrs = get_data (NULL, file, elf_header.e_phoff, 3204 elf_header.e_phentsize, elf_header.e_phnum, 3205 _("program headers")); 3206 if (!phdrs) 3207 return 0; 3208 3209 for (i = 0, internal = program_headers, external = phdrs; 3210 i < elf_header.e_phnum; 3211 i++, internal++, external++) 3212 { 3213 internal->p_type = BYTE_GET (external->p_type); 3214 internal->p_flags = BYTE_GET (external->p_flags); 3215 internal->p_offset = BYTE_GET (external->p_offset); 3216 internal->p_vaddr = BYTE_GET (external->p_vaddr); 3217 internal->p_paddr = BYTE_GET (external->p_paddr); 3218 internal->p_filesz = BYTE_GET (external->p_filesz); 3219 internal->p_memsz = BYTE_GET (external->p_memsz); 3220 internal->p_align = BYTE_GET (external->p_align); 3221 } 3222 3223 free (phdrs); 3224 3225 return 1; 3226 } 3227 3228 /* Returns 1 if the program headers were read into `program_headers'. */ 3229 3230 static int 3231 get_program_headers (FILE *file) 3232 { 3233 Elf_Internal_Phdr *phdrs; 3234 3235 /* Check cache of prior read. */ 3236 if (program_headers != NULL) 3237 return 1; 3238 3239 phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr)); 3240 3241 if (phdrs == NULL) 3242 { 3243 error (_("Out of memory\n")); 3244 return 0; 3245 } 3246 3247 if (is_32bit_elf 3248 ? get_32bit_program_headers (file, phdrs) 3249 : get_64bit_program_headers (file, phdrs)) 3250 { 3251 program_headers = phdrs; 3252 return 1; 3253 } 3254 3255 free (phdrs); 3256 return 0; 3257 } 3258 3259 /* Returns 1 if the program headers were loaded. */ 3260 3261 static int 3262 process_program_headers (FILE *file) 3263 { 3264 Elf_Internal_Phdr *segment; 3265 unsigned int i; 3266 3267 if (elf_header.e_phnum == 0) 3268 { 3269 if (do_segments) 3270 printf (_("\nThere are no program headers in this file.\n")); 3271 return 0; 3272 } 3273 3274 if (do_segments && !do_header) 3275 { 3276 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type)); 3277 printf (_("Entry point ")); 3278 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX); 3279 printf (_("\nThere are %d program headers, starting at offset "), 3280 elf_header.e_phnum); 3281 print_vma ((bfd_vma) elf_header.e_phoff, DEC); 3282 printf ("\n"); 3283 } 3284 3285 if (! get_program_headers (file)) 3286 return 0; 3287 3288 if (do_segments) 3289 { 3290 if (elf_header.e_phnum > 1) 3291 printf (_("\nProgram Headers:\n")); 3292 else 3293 printf (_("\nProgram Headers:\n")); 3294 3295 if (is_32bit_elf) 3296 printf 3297 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n")); 3298 else if (do_wide) 3299 printf 3300 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n")); 3301 else 3302 { 3303 printf 3304 (_(" Type Offset VirtAddr PhysAddr\n")); 3305 printf 3306 (_(" FileSiz MemSiz Flags Align\n")); 3307 } 3308 } 3309 3310 dynamic_addr = 0; 3311 dynamic_size = 0; 3312 3313 for (i = 0, segment = program_headers; 3314 i < elf_header.e_phnum; 3315 i++, segment++) 3316 { 3317 if (do_segments) 3318 { 3319 printf (" %-14.14s ", get_segment_type (segment->p_type)); 3320 3321 if (is_32bit_elf) 3322 { 3323 printf ("0x%6.6lx ", (unsigned long) segment->p_offset); 3324 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr); 3325 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr); 3326 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz); 3327 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz); 3328 printf ("%c%c%c ", 3329 (segment->p_flags & PF_R ? 'R' : ' '), 3330 (segment->p_flags & PF_W ? 'W' : ' '), 3331 (segment->p_flags & PF_X ? 'E' : ' ')); 3332 printf ("%#lx", (unsigned long) segment->p_align); 3333 } 3334 else if (do_wide) 3335 { 3336 if ((unsigned long) segment->p_offset == segment->p_offset) 3337 printf ("0x%6.6lx ", (unsigned long) segment->p_offset); 3338 else 3339 { 3340 print_vma (segment->p_offset, FULL_HEX); 3341 putchar (' '); 3342 } 3343 3344 print_vma (segment->p_vaddr, FULL_HEX); 3345 putchar (' '); 3346 print_vma (segment->p_paddr, FULL_HEX); 3347 putchar (' '); 3348 3349 if ((unsigned long) segment->p_filesz == segment->p_filesz) 3350 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz); 3351 else 3352 { 3353 print_vma (segment->p_filesz, FULL_HEX); 3354 putchar (' '); 3355 } 3356 3357 if ((unsigned long) segment->p_memsz == segment->p_memsz) 3358 printf ("0x%6.6lx", (unsigned long) segment->p_memsz); 3359 else 3360 { 3361 print_vma (segment->p_offset, FULL_HEX); 3362 } 3363 3364 printf (" %c%c%c ", 3365 (segment->p_flags & PF_R ? 'R' : ' '), 3366 (segment->p_flags & PF_W ? 'W' : ' '), 3367 (segment->p_flags & PF_X ? 'E' : ' ')); 3368 3369 if ((unsigned long) segment->p_align == segment->p_align) 3370 printf ("%#lx", (unsigned long) segment->p_align); 3371 else 3372 { 3373 print_vma (segment->p_align, PREFIX_HEX); 3374 } 3375 } 3376 else 3377 { 3378 print_vma (segment->p_offset, FULL_HEX); 3379 putchar (' '); 3380 print_vma (segment->p_vaddr, FULL_HEX); 3381 putchar (' '); 3382 print_vma (segment->p_paddr, FULL_HEX); 3383 printf ("\n "); 3384 print_vma (segment->p_filesz, FULL_HEX); 3385 putchar (' '); 3386 print_vma (segment->p_memsz, FULL_HEX); 3387 printf (" %c%c%c ", 3388 (segment->p_flags & PF_R ? 'R' : ' '), 3389 (segment->p_flags & PF_W ? 'W' : ' '), 3390 (segment->p_flags & PF_X ? 'E' : ' ')); 3391 print_vma (segment->p_align, HEX); 3392 } 3393 } 3394 3395 switch (segment->p_type) 3396 { 3397 case PT_DYNAMIC: 3398 if (dynamic_addr) 3399 error (_("more than one dynamic segment\n")); 3400 3401 /* Try to locate the .dynamic section. If there is 3402 a section header table, we can easily locate it. */ 3403 if (section_headers != NULL) 3404 { 3405 Elf_Internal_Shdr *sec; 3406 3407 sec = find_section (".dynamic"); 3408 if (sec == NULL || sec->sh_size == 0) 3409 { 3410 error (_("no .dynamic section in the dynamic segment")); 3411 break; 3412 } 3413 3414 dynamic_addr = sec->sh_offset; 3415 dynamic_size = sec->sh_size; 3416 3417 if (dynamic_addr < segment->p_offset 3418 || dynamic_addr > segment->p_offset + segment->p_filesz) 3419 warn (_("the .dynamic section is not contained within the dynamic segment")); 3420 else if (dynamic_addr > segment->p_offset) 3421 warn (_("the .dynamic section is not the first section in the dynamic segment.")); 3422 } 3423 else 3424 { 3425 /* Otherwise, we can only assume that the .dynamic 3426 section is the first section in the DYNAMIC segment. */ 3427 dynamic_addr = segment->p_offset; 3428 dynamic_size = segment->p_filesz; 3429 } 3430 break; 3431 3432 case PT_INTERP: 3433 if (fseek (file, archive_file_offset + (long) segment->p_offset, 3434 SEEK_SET)) 3435 error (_("Unable to find program interpreter name\n")); 3436 else 3437 { 3438 program_interpreter[0] = 0; 3439 fscanf (file, "%63s", program_interpreter); 3440 3441 if (do_segments) 3442 printf (_("\n [Requesting program interpreter: %s]"), 3443 program_interpreter); 3444 } 3445 break; 3446 } 3447 3448 if (do_segments) 3449 putc ('\n', stdout); 3450 } 3451 3452 if (do_segments && section_headers != NULL && string_table != NULL) 3453 { 3454 printf (_("\n Section to Segment mapping:\n")); 3455 printf (_(" Segment Sections...\n")); 3456 3457 for (i = 0; i < elf_header.e_phnum; i++) 3458 { 3459 unsigned int j; 3460 Elf_Internal_Shdr *section; 3461 3462 segment = program_headers + i; 3463 section = section_headers; 3464 3465 printf (" %2.2d ", i); 3466 3467 for (j = 1; j < elf_header.e_shnum; j++, section++) 3468 { 3469 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment)) 3470 printf ("%s ", SECTION_NAME (section)); 3471 } 3472 3473 putc ('\n',stdout); 3474 } 3475 } 3476 3477 return 1; 3478 } 3479 3480 3481 /* Find the file offset corresponding to VMA by using the program headers. */ 3482 3483 static long 3484 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size) 3485 { 3486 Elf_Internal_Phdr *seg; 3487 3488 if (! get_program_headers (file)) 3489 { 3490 warn (_("Cannot interpret virtual addresses without program headers.\n")); 3491 return (long) vma; 3492 } 3493 3494 for (seg = program_headers; 3495 seg < program_headers + elf_header.e_phnum; 3496 ++seg) 3497 { 3498 if (seg->p_type != PT_LOAD) 3499 continue; 3500 3501 if (vma >= (seg->p_vaddr & -seg->p_align) 3502 && vma + size <= seg->p_vaddr + seg->p_filesz) 3503 return vma - seg->p_vaddr + seg->p_offset; 3504 } 3505 3506 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"), 3507 (long) vma); 3508 return (long) vma; 3509 } 3510 3511 3512 static int 3513 get_32bit_section_headers (FILE *file, unsigned int num) 3514 { 3515 Elf32_External_Shdr *shdrs; 3516 Elf_Internal_Shdr *internal; 3517 unsigned int i; 3518 3519 shdrs = get_data (NULL, file, elf_header.e_shoff, 3520 elf_header.e_shentsize, num, _("section headers")); 3521 if (!shdrs) 3522 return 0; 3523 3524 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr)); 3525 3526 if (section_headers == NULL) 3527 { 3528 error (_("Out of memory\n")); 3529 return 0; 3530 } 3531 3532 for (i = 0, internal = section_headers; 3533 i < num; 3534 i++, internal++) 3535 { 3536 internal->sh_name = BYTE_GET (shdrs[i].sh_name); 3537 internal->sh_type = BYTE_GET (shdrs[i].sh_type); 3538 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags); 3539 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr); 3540 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset); 3541 internal->sh_size = BYTE_GET (shdrs[i].sh_size); 3542 internal->sh_link = BYTE_GET (shdrs[i].sh_link); 3543 internal->sh_info = BYTE_GET (shdrs[i].sh_info); 3544 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign); 3545 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize); 3546 } 3547 3548 free (shdrs); 3549 3550 return 1; 3551 } 3552 3553 static int 3554 get_64bit_section_headers (FILE *file, unsigned int num) 3555 { 3556 Elf64_External_Shdr *shdrs; 3557 Elf_Internal_Shdr *internal; 3558 unsigned int i; 3559 3560 shdrs = get_data (NULL, file, elf_header.e_shoff, 3561 elf_header.e_shentsize, num, _("section headers")); 3562 if (!shdrs) 3563 return 0; 3564 3565 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr)); 3566 3567 if (section_headers == NULL) 3568 { 3569 error (_("Out of memory\n")); 3570 return 0; 3571 } 3572 3573 for (i = 0, internal = section_headers; 3574 i < num; 3575 i++, internal++) 3576 { 3577 internal->sh_name = BYTE_GET (shdrs[i].sh_name); 3578 internal->sh_type = BYTE_GET (shdrs[i].sh_type); 3579 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags); 3580 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr); 3581 internal->sh_size = BYTE_GET (shdrs[i].sh_size); 3582 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize); 3583 internal->sh_link = BYTE_GET (shdrs[i].sh_link); 3584 internal->sh_info = BYTE_GET (shdrs[i].sh_info); 3585 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset); 3586 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign); 3587 } 3588 3589 free (shdrs); 3590 3591 return 1; 3592 } 3593 3594 static Elf_Internal_Sym * 3595 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section) 3596 { 3597 unsigned long number; 3598 Elf32_External_Sym *esyms; 3599 Elf_External_Sym_Shndx *shndx; 3600 Elf_Internal_Sym *isyms; 3601 Elf_Internal_Sym *psym; 3602 unsigned int j; 3603 3604 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size, 3605 _("symbols")); 3606 if (!esyms) 3607 return NULL; 3608 3609 shndx = NULL; 3610 if (symtab_shndx_hdr != NULL 3611 && (symtab_shndx_hdr->sh_link 3612 == (unsigned long) SECTION_HEADER_NUM (section - section_headers))) 3613 { 3614 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset, 3615 1, symtab_shndx_hdr->sh_size, _("symtab shndx")); 3616 if (!shndx) 3617 { 3618 free (esyms); 3619 return NULL; 3620 } 3621 } 3622 3623 number = section->sh_size / section->sh_entsize; 3624 isyms = cmalloc (number, sizeof (Elf_Internal_Sym)); 3625 3626 if (isyms == NULL) 3627 { 3628 error (_("Out of memory\n")); 3629 if (shndx) 3630 free (shndx); 3631 free (esyms); 3632 return NULL; 3633 } 3634 3635 for (j = 0, psym = isyms; 3636 j < number; 3637 j++, psym++) 3638 { 3639 psym->st_name = BYTE_GET (esyms[j].st_name); 3640 psym->st_value = BYTE_GET (esyms[j].st_value); 3641 psym->st_size = BYTE_GET (esyms[j].st_size); 3642 psym->st_shndx = BYTE_GET (esyms[j].st_shndx); 3643 if (psym->st_shndx == SHN_XINDEX && shndx != NULL) 3644 psym->st_shndx 3645 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j])); 3646 psym->st_info = BYTE_GET (esyms[j].st_info); 3647 psym->st_other = BYTE_GET (esyms[j].st_other); 3648 } 3649 3650 if (shndx) 3651 free (shndx); 3652 free (esyms); 3653 3654 return isyms; 3655 } 3656 3657 static Elf_Internal_Sym * 3658 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section) 3659 { 3660 unsigned long number; 3661 Elf64_External_Sym *esyms; 3662 Elf_External_Sym_Shndx *shndx; 3663 Elf_Internal_Sym *isyms; 3664 Elf_Internal_Sym *psym; 3665 unsigned int j; 3666 3667 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size, 3668 _("symbols")); 3669 if (!esyms) 3670 return NULL; 3671 3672 shndx = NULL; 3673 if (symtab_shndx_hdr != NULL 3674 && (symtab_shndx_hdr->sh_link 3675 == (unsigned long) SECTION_HEADER_NUM (section - section_headers))) 3676 { 3677 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset, 3678 1, symtab_shndx_hdr->sh_size, _("symtab shndx")); 3679 if (!shndx) 3680 { 3681 free (esyms); 3682 return NULL; 3683 } 3684 } 3685 3686 number = section->sh_size / section->sh_entsize; 3687 isyms = cmalloc (number, sizeof (Elf_Internal_Sym)); 3688 3689 if (isyms == NULL) 3690 { 3691 error (_("Out of memory\n")); 3692 if (shndx) 3693 free (shndx); 3694 free (esyms); 3695 return NULL; 3696 } 3697 3698 for (j = 0, psym = isyms; 3699 j < number; 3700 j++, psym++) 3701 { 3702 psym->st_name = BYTE_GET (esyms[j].st_name); 3703 psym->st_info = BYTE_GET (esyms[j].st_info); 3704 psym->st_other = BYTE_GET (esyms[j].st_other); 3705 psym->st_shndx = BYTE_GET (esyms[j].st_shndx); 3706 if (psym->st_shndx == SHN_XINDEX && shndx != NULL) 3707 psym->st_shndx 3708 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j])); 3709 psym->st_value = BYTE_GET (esyms[j].st_value); 3710 psym->st_size = BYTE_GET (esyms[j].st_size); 3711 } 3712 3713 if (shndx) 3714 free (shndx); 3715 free (esyms); 3716 3717 return isyms; 3718 } 3719 3720 static const char * 3721 get_elf_section_flags (bfd_vma sh_flags) 3722 { 3723 static char buff[1024]; 3724 char *p = buff; 3725 int field_size = is_32bit_elf ? 8 : 16; 3726 int index, size = sizeof (buff) - (field_size + 4 + 1); 3727 bfd_vma os_flags = 0; 3728 bfd_vma proc_flags = 0; 3729 bfd_vma unknown_flags = 0; 3730 const struct 3731 { 3732 const char *str; 3733 int len; 3734 } 3735 flags [] = 3736 { 3737 { "WRITE", 5 }, 3738 { "ALLOC", 5 }, 3739 { "EXEC", 4 }, 3740 { "MERGE", 5 }, 3741 { "STRINGS", 7 }, 3742 { "INFO LINK", 9 }, 3743 { "LINK ORDER", 10 }, 3744 { "OS NONCONF", 10 }, 3745 { "GROUP", 5 }, 3746 { "TLS", 3 } 3747 }; 3748 3749 if (do_section_details) 3750 { 3751 sprintf (buff, "[%*.*lx]: ", 3752 field_size, field_size, (unsigned long) sh_flags); 3753 p += field_size + 4; 3754 } 3755 3756 while (sh_flags) 3757 { 3758 bfd_vma flag; 3759 3760 flag = sh_flags & - sh_flags; 3761 sh_flags &= ~ flag; 3762 3763 if (do_section_details) 3764 { 3765 switch (flag) 3766 { 3767 case SHF_WRITE: index = 0; break; 3768 case SHF_ALLOC: index = 1; break; 3769 case SHF_EXECINSTR: index = 2; break; 3770 case SHF_MERGE: index = 3; break; 3771 case SHF_STRINGS: index = 4; break; 3772 case SHF_INFO_LINK: index = 5; break; 3773 case SHF_LINK_ORDER: index = 6; break; 3774 case SHF_OS_NONCONFORMING: index = 7; break; 3775 case SHF_GROUP: index = 8; break; 3776 case SHF_TLS: index = 9; break; 3777 3778 default: 3779 index = -1; 3780 break; 3781 } 3782 3783 if (index != -1) 3784 { 3785 if (p != buff + field_size + 4) 3786 { 3787 if (size < (10 + 2)) 3788 abort (); 3789 size -= 2; 3790 *p++ = ','; 3791 *p++ = ' '; 3792 } 3793 3794 size -= flags [index].len; 3795 #if 0 3796 p = stpcpy (p, flags [index].str); 3797 #else 3798 strcpy (p, flags [index].str); 3799 p += strlen(p); 3800 #endif 3801 } 3802 else if (flag & SHF_MASKOS) 3803 os_flags |= flag; 3804 else if (flag & SHF_MASKPROC) 3805 proc_flags |= flag; 3806 else 3807 unknown_flags |= flag; 3808 } 3809 else 3810 { 3811 switch (flag) 3812 { 3813 case SHF_WRITE: *p = 'W'; break; 3814 case SHF_ALLOC: *p = 'A'; break; 3815 case SHF_EXECINSTR: *p = 'X'; break; 3816 case SHF_MERGE: *p = 'M'; break; 3817 case SHF_STRINGS: *p = 'S'; break; 3818 case SHF_INFO_LINK: *p = 'I'; break; 3819 case SHF_LINK_ORDER: *p = 'L'; break; 3820 case SHF_OS_NONCONFORMING: *p = 'O'; break; 3821 case SHF_GROUP: *p = 'G'; break; 3822 case SHF_TLS: *p = 'T'; break; 3823 3824 default: 3825 if (elf_header.e_machine == EM_X86_64 3826 && flag == SHF_X86_64_LARGE) 3827 *p = 'l'; 3828 else if (flag & SHF_MASKOS) 3829 { 3830 *p = 'o'; 3831 sh_flags &= ~ SHF_MASKOS; 3832 } 3833 else if (flag & SHF_MASKPROC) 3834 { 3835 *p = 'p'; 3836 sh_flags &= ~ SHF_MASKPROC; 3837 } 3838 else 3839 *p = 'x'; 3840 break; 3841 } 3842 p++; 3843 } 3844 } 3845 3846 if (do_section_details) 3847 { 3848 if (os_flags) 3849 { 3850 size -= 5 + field_size; 3851 if (p != buff + field_size + 4) 3852 { 3853 if (size < (2 + 1)) 3854 abort (); 3855 size -= 2; 3856 *p++ = ','; 3857 *p++ = ' '; 3858 } 3859 sprintf (p, "OS (%*.*lx)", field_size, field_size, 3860 (unsigned long) os_flags); 3861 p += 5 + field_size; 3862 } 3863 if (proc_flags) 3864 { 3865 size -= 7 + field_size; 3866 if (p != buff + field_size + 4) 3867 { 3868 if (size < (2 + 1)) 3869 abort (); 3870 size -= 2; 3871 *p++ = ','; 3872 *p++ = ' '; 3873 } 3874 sprintf (p, "PROC (%*.*lx)", field_size, field_size, 3875 (unsigned long) proc_flags); 3876 p += 7 + field_size; 3877 } 3878 if (unknown_flags) 3879 { 3880 size -= 10 + field_size; 3881 if (p != buff + field_size + 4) 3882 { 3883 if (size < (2 + 1)) 3884 abort (); 3885 size -= 2; 3886 *p++ = ','; 3887 *p++ = ' '; 3888 } 3889 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size, 3890 (unsigned long) unknown_flags); 3891 p += 10 + field_size; 3892 } 3893 } 3894 3895 *p = '\0'; 3896 return buff; 3897 } 3898 3899 static int 3900 process_section_headers (FILE *file) 3901 { 3902 Elf_Internal_Shdr *section; 3903 unsigned int i; 3904 3905 section_headers = NULL; 3906 3907 if (elf_header.e_shnum == 0) 3908 { 3909 if (do_sections) 3910 printf (_("\nThere are no sections in this file.\n")); 3911 3912 return 1; 3913 } 3914 3915 if (do_sections && !do_header) 3916 printf (_("There are %d section headers, starting at offset 0x%lx:\n"), 3917 elf_header.e_shnum, (unsigned long) elf_header.e_shoff); 3918 3919 if (is_32bit_elf) 3920 { 3921 if (! get_32bit_section_headers (file, elf_header.e_shnum)) 3922 return 0; 3923 } 3924 else if (! get_64bit_section_headers (file, elf_header.e_shnum)) 3925 return 0; 3926 3927 /* Read in the string table, so that we have names to display. */ 3928 if (SECTION_HEADER_INDEX (elf_header.e_shstrndx) < elf_header.e_shnum) 3929 { 3930 section = SECTION_HEADER (elf_header.e_shstrndx); 3931 3932 if (section->sh_size != 0) 3933 { 3934 string_table = get_data (NULL, file, section->sh_offset, 3935 1, section->sh_size, _("string table")); 3936 3937 string_table_length = string_table != NULL ? section->sh_size : 0; 3938 } 3939 } 3940 3941 /* Scan the sections for the dynamic symbol table 3942 and dynamic string table and debug sections. */ 3943 dynamic_symbols = NULL; 3944 dynamic_strings = NULL; 3945 dynamic_syminfo = NULL; 3946 symtab_shndx_hdr = NULL; 3947 3948 eh_addr_size = is_32bit_elf ? 4 : 8; 3949 switch (elf_header.e_machine) 3950 { 3951 case EM_MIPS: 3952 case EM_MIPS_RS3_LE: 3953 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit 3954 FDE addresses. However, the ABI also has a semi-official ILP32 3955 variant for which the normal FDE address size rules apply. 3956 3957 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX 3958 section, where XX is the size of longs in bits. Unfortunately, 3959 earlier compilers provided no way of distinguishing ILP32 objects 3960 from LP64 objects, so if there's any doubt, we should assume that 3961 the official LP64 form is being used. */ 3962 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64 3963 && find_section (".gcc_compiled_long32") == NULL) 3964 eh_addr_size = 8; 3965 break; 3966 } 3967 3968 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \ 3969 do \ 3970 { \ 3971 size_t expected_entsize \ 3972 = is_32bit_elf ? size32 : size64; \ 3973 if (section->sh_entsize != expected_entsize) \ 3974 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \ 3975 i, (unsigned long int) section->sh_entsize, \ 3976 (unsigned long int) expected_entsize); \ 3977 section->sh_entsize = expected_entsize; \ 3978 } \ 3979 while (0) 3980 #define CHECK_ENTSIZE(section, i, type) \ 3981 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \ 3982 sizeof (Elf64_External_##type)) 3983 3984 for (i = 0, section = section_headers; 3985 i < elf_header.e_shnum; 3986 i++, section++) 3987 { 3988 char *name = SECTION_NAME (section); 3989 3990 if (section->sh_type == SHT_DYNSYM) 3991 { 3992 if (dynamic_symbols != NULL) 3993 { 3994 error (_("File contains multiple dynamic symbol tables\n")); 3995 continue; 3996 } 3997 3998 CHECK_ENTSIZE (section, i, Sym); 3999 num_dynamic_syms = section->sh_size / section->sh_entsize; 4000 dynamic_symbols = GET_ELF_SYMBOLS (file, section); 4001 } 4002 else if (section->sh_type == SHT_STRTAB 4003 && streq (name, ".dynstr")) 4004 { 4005 if (dynamic_strings != NULL) 4006 { 4007 error (_("File contains multiple dynamic string tables\n")); 4008 continue; 4009 } 4010 4011 dynamic_strings = get_data (NULL, file, section->sh_offset, 4012 1, section->sh_size, _("dynamic strings")); 4013 dynamic_strings_length = section->sh_size; 4014 } 4015 else if (section->sh_type == SHT_SYMTAB_SHNDX) 4016 { 4017 if (symtab_shndx_hdr != NULL) 4018 { 4019 error (_("File contains multiple symtab shndx tables\n")); 4020 continue; 4021 } 4022 symtab_shndx_hdr = section; 4023 } 4024 else if (section->sh_type == SHT_SYMTAB) 4025 CHECK_ENTSIZE (section, i, Sym); 4026 else if (section->sh_type == SHT_GROUP) 4027 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE); 4028 else if (section->sh_type == SHT_REL) 4029 CHECK_ENTSIZE (section, i, Rel); 4030 else if (section->sh_type == SHT_RELA) 4031 CHECK_ENTSIZE (section, i, Rela); 4032 else if ((do_debugging || do_debug_info || do_debug_abbrevs 4033 || do_debug_lines || do_debug_pubnames || do_debug_aranges 4034 || do_debug_frames || do_debug_macinfo || do_debug_str 4035 || do_debug_loc || do_debug_ranges) 4036 && strneq (name, ".debug_", 7)) 4037 { 4038 name += 7; 4039 4040 if (do_debugging 4041 || (do_debug_info && streq (name, "info")) 4042 || (do_debug_abbrevs && streq (name, "abbrev")) 4043 || (do_debug_lines && streq (name, "line")) 4044 || (do_debug_pubnames && streq (name, "pubnames")) 4045 || (do_debug_aranges && streq (name, "aranges")) 4046 || (do_debug_ranges && streq (name, "ranges")) 4047 || (do_debug_frames && streq (name, "frame")) 4048 || (do_debug_macinfo && streq (name, "macinfo")) 4049 || (do_debug_str && streq (name, "str")) 4050 || (do_debug_loc && streq (name, "loc")) 4051 ) 4052 request_dump (i, DEBUG_DUMP); 4053 } 4054 /* linkonce section to be combined with .debug_info at link time. */ 4055 else if ((do_debugging || do_debug_info) 4056 && strneq (name, ".gnu.linkonce.wi.", 17)) 4057 request_dump (i, DEBUG_DUMP); 4058 else if (do_debug_frames && streq (name, ".eh_frame")) 4059 request_dump (i, DEBUG_DUMP); 4060 } 4061 4062 if (! do_sections) 4063 return 1; 4064 4065 if (elf_header.e_shnum > 1) 4066 printf (_("\nSection Headers:\n")); 4067 else 4068 printf (_("\nSection Header:\n")); 4069 4070 if (is_32bit_elf) 4071 { 4072 if (do_section_details) 4073 { 4074 printf (_(" [Nr] Name\n")); 4075 printf (_(" Type Addr Off Size ES Lk Inf Al\n")); 4076 } 4077 else 4078 printf 4079 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n")); 4080 } 4081 else if (do_wide) 4082 { 4083 if (do_section_details) 4084 { 4085 printf (_(" [Nr] Name\n")); 4086 printf (_(" Type Address Off Size ES Lk Inf Al\n")); 4087 } 4088 else 4089 printf 4090 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n")); 4091 } 4092 else 4093 { 4094 if (do_section_details) 4095 { 4096 printf (_(" [Nr] Name\n")); 4097 printf (_(" Type Address Offset Link\n")); 4098 printf (_(" Size EntSize Info Align\n")); 4099 } 4100 else 4101 { 4102 printf (_(" [Nr] Name Type Address Offset\n")); 4103 printf (_(" Size EntSize Flags Link Info Align\n")); 4104 } 4105 } 4106 4107 if (do_section_details) 4108 printf (_(" Flags\n")); 4109 4110 for (i = 0, section = section_headers; 4111 i < elf_header.e_shnum; 4112 i++, section++) 4113 { 4114 if (do_section_details) 4115 { 4116 printf (" [%2u] %s\n", 4117 SECTION_HEADER_NUM (i), 4118 SECTION_NAME (section)); 4119 if (is_32bit_elf || do_wide) 4120 printf (" %-15.15s ", 4121 get_section_type_name (section->sh_type)); 4122 } 4123 else 4124 printf (" [%2u] %-17.17s %-15.15s ", 4125 SECTION_HEADER_NUM (i), 4126 SECTION_NAME (section), 4127 get_section_type_name (section->sh_type)); 4128 4129 if (is_32bit_elf) 4130 { 4131 print_vma (section->sh_addr, LONG_HEX); 4132 4133 printf ( " %6.6lx %6.6lx %2.2lx", 4134 (unsigned long) section->sh_offset, 4135 (unsigned long) section->sh_size, 4136 (unsigned long) section->sh_entsize); 4137 4138 if (do_section_details) 4139 fputs (" ", stdout); 4140 else 4141 printf (" %3s ", get_elf_section_flags (section->sh_flags)); 4142 4143 printf ("%2ld %3lu %2ld\n", 4144 (unsigned long) section->sh_link, 4145 (unsigned long) section->sh_info, 4146 (unsigned long) section->sh_addralign); 4147 } 4148 else if (do_wide) 4149 { 4150 print_vma (section->sh_addr, LONG_HEX); 4151 4152 if ((long) section->sh_offset == section->sh_offset) 4153 printf (" %6.6lx", (unsigned long) section->sh_offset); 4154 else 4155 { 4156 putchar (' '); 4157 print_vma (section->sh_offset, LONG_HEX); 4158 } 4159 4160 if ((unsigned long) section->sh_size == section->sh_size) 4161 printf (" %6.6lx", (unsigned long) section->sh_size); 4162 else 4163 { 4164 putchar (' '); 4165 print_vma (section->sh_size, LONG_HEX); 4166 } 4167 4168 if ((unsigned long) section->sh_entsize == section->sh_entsize) 4169 printf (" %2.2lx", (unsigned long) section->sh_entsize); 4170 else 4171 { 4172 putchar (' '); 4173 print_vma (section->sh_entsize, LONG_HEX); 4174 } 4175 4176 if (do_section_details) 4177 fputs (" ", stdout); 4178 else 4179 printf (" %3s ", get_elf_section_flags (section->sh_flags)); 4180 4181 printf ("%2ld %3lu ", 4182 (unsigned long) section->sh_link, 4183 (unsigned long) section->sh_info); 4184 4185 if ((unsigned long) section->sh_addralign == section->sh_addralign) 4186 printf ("%2ld\n", (unsigned long) section->sh_addralign); 4187 else 4188 { 4189 print_vma (section->sh_addralign, DEC); 4190 putchar ('\n'); 4191 } 4192 } 4193 else if (do_section_details) 4194 { 4195 printf (" %-15.15s ", 4196 get_section_type_name (section->sh_type)); 4197 print_vma (section->sh_addr, LONG_HEX); 4198 if ((long) section->sh_offset == section->sh_offset) 4199 printf (" %16.16lx", (unsigned long) section->sh_offset); 4200 else 4201 { 4202 printf (" "); 4203 print_vma (section->sh_offset, LONG_HEX); 4204 } 4205 printf (" %ld\n ", (unsigned long) section->sh_link); 4206 print_vma (section->sh_size, LONG_HEX); 4207 putchar (' '); 4208 print_vma (section->sh_entsize, LONG_HEX); 4209 4210 printf (" %-16lu %ld\n", 4211 (unsigned long) section->sh_info, 4212 (unsigned long) section->sh_addralign); 4213 } 4214 else 4215 { 4216 putchar (' '); 4217 print_vma (section->sh_addr, LONG_HEX); 4218 if ((long) section->sh_offset == section->sh_offset) 4219 printf (" %8.8lx", (unsigned long) section->sh_offset); 4220 else 4221 { 4222 printf (" "); 4223 print_vma (section->sh_offset, LONG_HEX); 4224 } 4225 printf ("\n "); 4226 print_vma (section->sh_size, LONG_HEX); 4227 printf (" "); 4228 print_vma (section->sh_entsize, LONG_HEX); 4229 4230 printf (" %3s ", get_elf_section_flags (section->sh_flags)); 4231 4232 printf (" %2ld %3lu %ld\n", 4233 (unsigned long) section->sh_link, 4234 (unsigned long) section->sh_info, 4235 (unsigned long) section->sh_addralign); 4236 } 4237 4238 if (do_section_details) 4239 printf (" %s\n", get_elf_section_flags (section->sh_flags)); 4240 } 4241 4242 if (!do_section_details) 4243 printf (_("Key to Flags:\n\ 4244 W (write), A (alloc), X (execute), M (merge), S (strings)\n\ 4245 I (info), L (link order), G (group), x (unknown)\n\ 4246 O (extra OS processing required) o (OS specific), p (processor specific)\n")); 4247 4248 return 1; 4249 } 4250 4251 static const char * 4252 get_group_flags (unsigned int flags) 4253 { 4254 static char buff[32]; 4255 switch (flags) 4256 { 4257 case GRP_COMDAT: 4258 return "COMDAT"; 4259 4260 default: 4261 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags); 4262 break; 4263 } 4264 return buff; 4265 } 4266 4267 static int 4268 process_section_groups (FILE *file) 4269 { 4270 Elf_Internal_Shdr *section; 4271 unsigned int i; 4272 struct group *group; 4273 Elf_Internal_Shdr *symtab_sec, *strtab_sec; 4274 Elf_Internal_Sym *symtab; 4275 char *strtab; 4276 size_t strtab_size; 4277 4278 /* Don't process section groups unless needed. */ 4279 if (!do_unwind && !do_section_groups) 4280 return 1; 4281 4282 if (elf_header.e_shnum == 0) 4283 { 4284 if (do_section_groups) 4285 printf (_("\nThere are no sections in this file.\n")); 4286 4287 return 1; 4288 } 4289 4290 if (section_headers == NULL) 4291 { 4292 error (_("Section headers are not available!\n")); 4293 abort (); 4294 } 4295 4296 section_headers_groups = calloc (elf_header.e_shnum, 4297 sizeof (struct group *)); 4298 4299 if (section_headers_groups == NULL) 4300 { 4301 error (_("Out of memory\n")); 4302 return 0; 4303 } 4304 4305 /* Scan the sections for the group section. */ 4306 group_count = 0; 4307 for (i = 0, section = section_headers; 4308 i < elf_header.e_shnum; 4309 i++, section++) 4310 if (section->sh_type == SHT_GROUP) 4311 group_count++; 4312 4313 if (group_count == 0) 4314 { 4315 if (do_section_groups) 4316 printf (_("\nThere are no section groups in this file.\n")); 4317 4318 return 1; 4319 } 4320 4321 section_groups = calloc (group_count, sizeof (struct group)); 4322 4323 if (section_groups == NULL) 4324 { 4325 error (_("Out of memory\n")); 4326 return 0; 4327 } 4328 4329 symtab_sec = NULL; 4330 strtab_sec = NULL; 4331 symtab = NULL; 4332 strtab = NULL; 4333 strtab_size = 0; 4334 for (i = 0, section = section_headers, group = section_groups; 4335 i < elf_header.e_shnum; 4336 i++, section++) 4337 { 4338 if (section->sh_type == SHT_GROUP) 4339 { 4340 char *name = SECTION_NAME (section); 4341 char *group_name; 4342 unsigned char *start, *indices; 4343 unsigned int entry, j, size; 4344 Elf_Internal_Shdr *sec; 4345 Elf_Internal_Sym *sym; 4346 4347 /* Get the symbol table. */ 4348 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum 4349 || ((sec = SECTION_HEADER (section->sh_link))->sh_type 4350 != SHT_SYMTAB)) 4351 { 4352 error (_("Bad sh_link in group section `%s'\n"), name); 4353 continue; 4354 } 4355 4356 if (symtab_sec != sec) 4357 { 4358 symtab_sec = sec; 4359 if (symtab) 4360 free (symtab); 4361 symtab = GET_ELF_SYMBOLS (file, symtab_sec); 4362 } 4363 4364 sym = symtab + section->sh_info; 4365 4366 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 4367 { 4368 bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx); 4369 if (sec_index == 0) 4370 { 4371 error (_("Bad sh_info in group section `%s'\n"), name); 4372 continue; 4373 } 4374 4375 group_name = SECTION_NAME (section_headers + sec_index); 4376 strtab_sec = NULL; 4377 if (strtab) 4378 free (strtab); 4379 strtab = NULL; 4380 strtab_size = 0; 4381 } 4382 else 4383 { 4384 /* Get the string table. */ 4385 if (SECTION_HEADER_INDEX (symtab_sec->sh_link) 4386 >= elf_header.e_shnum) 4387 { 4388 strtab_sec = NULL; 4389 if (strtab) 4390 free (strtab); 4391 strtab = NULL; 4392 strtab_size = 0; 4393 } 4394 else if (strtab_sec 4395 != (sec = SECTION_HEADER (symtab_sec->sh_link))) 4396 { 4397 strtab_sec = sec; 4398 if (strtab) 4399 free (strtab); 4400 strtab = get_data (NULL, file, strtab_sec->sh_offset, 4401 1, strtab_sec->sh_size, 4402 _("string table")); 4403 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0; 4404 } 4405 group_name = sym->st_name < strtab_size 4406 ? strtab + sym->st_name : "<corrupt>"; 4407 } 4408 4409 start = get_data (NULL, file, section->sh_offset, 4410 1, section->sh_size, _("section data")); 4411 4412 indices = start; 4413 size = (section->sh_size / section->sh_entsize) - 1; 4414 entry = byte_get (indices, 4); 4415 indices += 4; 4416 4417 if (do_section_groups) 4418 { 4419 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n", 4420 get_group_flags (entry), i, name, group_name, size); 4421 4422 printf (_(" [Index] Name\n")); 4423 } 4424 4425 group->group_index = i; 4426 4427 for (j = 0; j < size; j++) 4428 { 4429 struct group_list *g; 4430 4431 entry = byte_get (indices, 4); 4432 indices += 4; 4433 4434 if (SECTION_HEADER_INDEX (entry) >= elf_header.e_shnum) 4435 { 4436 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"), 4437 entry, i, elf_header.e_shnum - 1); 4438 continue; 4439 } 4440 else if (entry >= SHN_LORESERVE && entry <= SHN_HIRESERVE) 4441 { 4442 error (_("invalid section [%5u] in group section [%5u]\n"), 4443 entry, i); 4444 continue; 4445 } 4446 4447 if (section_headers_groups [SECTION_HEADER_INDEX (entry)] 4448 != NULL) 4449 { 4450 if (entry) 4451 { 4452 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"), 4453 entry, i, 4454 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index); 4455 continue; 4456 } 4457 else 4458 { 4459 /* Intel C/C++ compiler may put section 0 in a 4460 section group. We just warn it the first time 4461 and ignore it afterwards. */ 4462 static int warned = 0; 4463 if (!warned) 4464 { 4465 error (_("section 0 in group section [%5u]\n"), 4466 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index); 4467 warned++; 4468 } 4469 } 4470 } 4471 4472 section_headers_groups [SECTION_HEADER_INDEX (entry)] 4473 = group; 4474 4475 if (do_section_groups) 4476 { 4477 sec = SECTION_HEADER (entry); 4478 printf (" [%5u] %s\n", entry, SECTION_NAME (sec)); 4479 } 4480 4481 g = xmalloc (sizeof (struct group_list)); 4482 g->section_index = entry; 4483 g->next = group->root; 4484 group->root = g; 4485 } 4486 4487 if (start) 4488 free (start); 4489 4490 group++; 4491 } 4492 } 4493 4494 if (symtab) 4495 free (symtab); 4496 if (strtab) 4497 free (strtab); 4498 return 1; 4499 } 4500 4501 static struct 4502 { 4503 const char *name; 4504 int reloc; 4505 int size; 4506 int rela; 4507 } dynamic_relocations [] = 4508 { 4509 { "REL", DT_REL, DT_RELSZ, FALSE }, 4510 { "RELA", DT_RELA, DT_RELASZ, TRUE }, 4511 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN } 4512 }; 4513 4514 /* Process the reloc section. */ 4515 4516 static int 4517 process_relocs (FILE *file) 4518 { 4519 unsigned long rel_size; 4520 unsigned long rel_offset; 4521 4522 4523 if (!do_reloc) 4524 return 1; 4525 4526 if (do_using_dynamic) 4527 { 4528 int is_rela; 4529 const char *name; 4530 int has_dynamic_reloc; 4531 unsigned int i; 4532 4533 has_dynamic_reloc = 0; 4534 4535 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++) 4536 { 4537 is_rela = dynamic_relocations [i].rela; 4538 name = dynamic_relocations [i].name; 4539 rel_size = dynamic_info [dynamic_relocations [i].size]; 4540 rel_offset = dynamic_info [dynamic_relocations [i].reloc]; 4541 4542 has_dynamic_reloc |= rel_size; 4543 4544 if (is_rela == UNKNOWN) 4545 { 4546 if (dynamic_relocations [i].reloc == DT_JMPREL) 4547 switch (dynamic_info[DT_PLTREL]) 4548 { 4549 case DT_REL: 4550 is_rela = FALSE; 4551 break; 4552 case DT_RELA: 4553 is_rela = TRUE; 4554 break; 4555 } 4556 } 4557 4558 if (rel_size) 4559 { 4560 printf 4561 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"), 4562 name, rel_offset, rel_size); 4563 4564 dump_relocations (file, 4565 offset_from_vma (file, rel_offset, rel_size), 4566 rel_size, 4567 dynamic_symbols, num_dynamic_syms, 4568 dynamic_strings, dynamic_strings_length, is_rela); 4569 } 4570 } 4571 4572 if (! has_dynamic_reloc) 4573 printf (_("\nThere are no dynamic relocations in this file.\n")); 4574 } 4575 else 4576 { 4577 Elf_Internal_Shdr *section; 4578 unsigned long i; 4579 int found = 0; 4580 4581 for (i = 0, section = section_headers; 4582 i < elf_header.e_shnum; 4583 i++, section++) 4584 { 4585 if ( section->sh_type != SHT_RELA 4586 && section->sh_type != SHT_REL) 4587 continue; 4588 4589 rel_offset = section->sh_offset; 4590 rel_size = section->sh_size; 4591 4592 if (rel_size) 4593 { 4594 Elf_Internal_Shdr *strsec; 4595 int is_rela; 4596 4597 printf (_("\nRelocation section ")); 4598 4599 if (string_table == NULL) 4600 printf ("%d", section->sh_name); 4601 else 4602 printf (_("'%s'"), SECTION_NAME (section)); 4603 4604 printf (_(" at offset 0x%lx contains %lu entries:\n"), 4605 rel_offset, (unsigned long) (rel_size / section->sh_entsize)); 4606 4607 is_rela = section->sh_type == SHT_RELA; 4608 4609 if (section->sh_link 4610 && SECTION_HEADER_INDEX (section->sh_link) 4611 < elf_header.e_shnum) 4612 { 4613 Elf_Internal_Shdr *symsec; 4614 Elf_Internal_Sym *symtab; 4615 unsigned long nsyms; 4616 unsigned long strtablen = 0; 4617 char *strtab = NULL; 4618 4619 symsec = SECTION_HEADER (section->sh_link); 4620 if (symsec->sh_type != SHT_SYMTAB 4621 && symsec->sh_type != SHT_DYNSYM) 4622 continue; 4623 4624 nsyms = symsec->sh_size / symsec->sh_entsize; 4625 symtab = GET_ELF_SYMBOLS (file, symsec); 4626 4627 if (symtab == NULL) 4628 continue; 4629 4630 if (SECTION_HEADER_INDEX (symsec->sh_link) 4631 < elf_header.e_shnum) 4632 { 4633 strsec = SECTION_HEADER (symsec->sh_link); 4634 4635 strtab = get_data (NULL, file, strsec->sh_offset, 4636 1, strsec->sh_size, 4637 _("string table")); 4638 strtablen = strtab == NULL ? 0 : strsec->sh_size; 4639 } 4640 4641 dump_relocations (file, rel_offset, rel_size, 4642 symtab, nsyms, strtab, strtablen, is_rela); 4643 if (strtab) 4644 free (strtab); 4645 free (symtab); 4646 } 4647 else 4648 dump_relocations (file, rel_offset, rel_size, 4649 NULL, 0, NULL, 0, is_rela); 4650 4651 found = 1; 4652 } 4653 } 4654 4655 if (! found) 4656 printf (_("\nThere are no relocations in this file.\n")); 4657 } 4658 4659 return 1; 4660 } 4661 4662 /* Process the unwind section. */ 4663 4664 #include "unwind-ia64.h" 4665 4666 /* An absolute address consists of a section and an offset. If the 4667 section is NULL, the offset itself is the address, otherwise, the 4668 address equals to LOAD_ADDRESS(section) + offset. */ 4669 4670 struct absaddr 4671 { 4672 unsigned short section; 4673 bfd_vma offset; 4674 }; 4675 4676 #define ABSADDR(a) \ 4677 ((a).section \ 4678 ? section_headers [(a).section].sh_addr + (a).offset \ 4679 : (a).offset) 4680 4681 struct ia64_unw_aux_info 4682 { 4683 struct ia64_unw_table_entry 4684 { 4685 struct absaddr start; 4686 struct absaddr end; 4687 struct absaddr info; 4688 } 4689 *table; /* Unwind table. */ 4690 unsigned long table_len; /* Length of unwind table. */ 4691 unsigned char *info; /* Unwind info. */ 4692 unsigned long info_size; /* Size of unwind info. */ 4693 bfd_vma info_addr; /* starting address of unwind info. */ 4694 bfd_vma seg_base; /* Starting address of segment. */ 4695 Elf_Internal_Sym *symtab; /* The symbol table. */ 4696 unsigned long nsyms; /* Number of symbols. */ 4697 char *strtab; /* The string table. */ 4698 unsigned long strtab_size; /* Size of string table. */ 4699 }; 4700 4701 static void 4702 find_symbol_for_address (Elf_Internal_Sym *symtab, 4703 unsigned long nsyms, 4704 const char *strtab, 4705 unsigned long strtab_size, 4706 struct absaddr addr, 4707 const char **symname, 4708 bfd_vma *offset) 4709 { 4710 bfd_vma dist = 0x100000; 4711 Elf_Internal_Sym *sym, *best = NULL; 4712 unsigned long i; 4713 4714 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym) 4715 { 4716 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC 4717 && sym->st_name != 0 4718 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx) 4719 && addr.offset >= sym->st_value 4720 && addr.offset - sym->st_value < dist) 4721 { 4722 best = sym; 4723 dist = addr.offset - sym->st_value; 4724 if (!dist) 4725 break; 4726 } 4727 } 4728 if (best) 4729 { 4730 *symname = (best->st_name >= strtab_size 4731 ? "<corrupt>" : strtab + best->st_name); 4732 *offset = dist; 4733 return; 4734 } 4735 *symname = NULL; 4736 *offset = addr.offset; 4737 } 4738 4739 static void 4740 dump_ia64_unwind (struct ia64_unw_aux_info *aux) 4741 { 4742 struct ia64_unw_table_entry *tp; 4743 int in_body; 4744 4745 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp) 4746 { 4747 bfd_vma stamp; 4748 bfd_vma offset; 4749 const unsigned char *dp; 4750 const unsigned char *head; 4751 const char *procname; 4752 4753 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab, 4754 aux->strtab_size, tp->start, &procname, &offset); 4755 4756 fputs ("\n<", stdout); 4757 4758 if (procname) 4759 { 4760 fputs (procname, stdout); 4761 4762 if (offset) 4763 printf ("+%lx", (unsigned long) offset); 4764 } 4765 4766 fputs (">: [", stdout); 4767 print_vma (tp->start.offset, PREFIX_HEX); 4768 fputc ('-', stdout); 4769 print_vma (tp->end.offset, PREFIX_HEX); 4770 printf ("], info at +0x%lx\n", 4771 (unsigned long) (tp->info.offset - aux->seg_base)); 4772 4773 head = aux->info + (ABSADDR (tp->info) - aux->info_addr); 4774 stamp = byte_get ((unsigned char *) head, sizeof (stamp)); 4775 4776 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n", 4777 (unsigned) UNW_VER (stamp), 4778 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32), 4779 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "", 4780 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "", 4781 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp))); 4782 4783 if (UNW_VER (stamp) != 1) 4784 { 4785 printf ("\tUnknown version.\n"); 4786 continue; 4787 } 4788 4789 in_body = 0; 4790 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);) 4791 dp = unw_decode (dp, in_body, & in_body); 4792 } 4793 } 4794 4795 static int 4796 slurp_ia64_unwind_table (FILE *file, 4797 struct ia64_unw_aux_info *aux, 4798 Elf_Internal_Shdr *sec) 4799 { 4800 unsigned long size, nrelas, i; 4801 Elf_Internal_Phdr *seg; 4802 struct ia64_unw_table_entry *tep; 4803 Elf_Internal_Shdr *relsec; 4804 Elf_Internal_Rela *rela, *rp; 4805 unsigned char *table, *tp; 4806 Elf_Internal_Sym *sym; 4807 const char *relname; 4808 4809 /* First, find the starting address of the segment that includes 4810 this section: */ 4811 4812 if (elf_header.e_phnum) 4813 { 4814 if (! get_program_headers (file)) 4815 return 0; 4816 4817 for (seg = program_headers; 4818 seg < program_headers + elf_header.e_phnum; 4819 ++seg) 4820 { 4821 if (seg->p_type != PT_LOAD) 4822 continue; 4823 4824 if (sec->sh_addr >= seg->p_vaddr 4825 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz)) 4826 { 4827 aux->seg_base = seg->p_vaddr; 4828 break; 4829 } 4830 } 4831 } 4832 4833 /* Second, build the unwind table from the contents of the unwind section: */ 4834 size = sec->sh_size; 4835 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table")); 4836 if (!table) 4837 return 0; 4838 4839 aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0])); 4840 tep = aux->table; 4841 for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep) 4842 { 4843 tep->start.section = SHN_UNDEF; 4844 tep->end.section = SHN_UNDEF; 4845 tep->info.section = SHN_UNDEF; 4846 if (is_32bit_elf) 4847 { 4848 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4); 4849 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4); 4850 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4); 4851 } 4852 else 4853 { 4854 tep->start.offset = BYTE_GET ((unsigned char *) tp + 0); 4855 tep->end.offset = BYTE_GET ((unsigned char *) tp + 8); 4856 tep->info.offset = BYTE_GET ((unsigned char *) tp + 16); 4857 } 4858 tep->start.offset += aux->seg_base; 4859 tep->end.offset += aux->seg_base; 4860 tep->info.offset += aux->seg_base; 4861 } 4862 free (table); 4863 4864 /* Third, apply any relocations to the unwind table: */ 4865 4866 for (relsec = section_headers; 4867 relsec < section_headers + elf_header.e_shnum; 4868 ++relsec) 4869 { 4870 if (relsec->sh_type != SHT_RELA 4871 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum 4872 || SECTION_HEADER (relsec->sh_info) != sec) 4873 continue; 4874 4875 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size, 4876 & rela, & nrelas)) 4877 return 0; 4878 4879 for (rp = rela; rp < rela + nrelas; ++rp) 4880 { 4881 if (is_32bit_elf) 4882 { 4883 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info)); 4884 sym = aux->symtab + ELF32_R_SYM (rp->r_info); 4885 } 4886 else 4887 { 4888 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info)); 4889 sym = aux->symtab + ELF64_R_SYM (rp->r_info); 4890 } 4891 4892 if (! strneq (relname, "R_IA64_SEGREL", 13)) 4893 { 4894 warn (_("Skipping unexpected relocation type %s\n"), relname); 4895 continue; 4896 } 4897 4898 i = rp->r_offset / (3 * eh_addr_size); 4899 4900 switch (rp->r_offset/eh_addr_size % 3) 4901 { 4902 case 0: 4903 aux->table[i].start.section = sym->st_shndx; 4904 aux->table[i].start.offset += rp->r_addend + sym->st_value; 4905 break; 4906 case 1: 4907 aux->table[i].end.section = sym->st_shndx; 4908 aux->table[i].end.offset += rp->r_addend + sym->st_value; 4909 break; 4910 case 2: 4911 aux->table[i].info.section = sym->st_shndx; 4912 aux->table[i].info.offset += rp->r_addend + sym->st_value; 4913 break; 4914 default: 4915 break; 4916 } 4917 } 4918 4919 free (rela); 4920 } 4921 4922 aux->table_len = size / (3 * eh_addr_size); 4923 return 1; 4924 } 4925 4926 static int 4927 ia64_process_unwind (FILE *file) 4928 { 4929 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec; 4930 unsigned long i, unwcount = 0, unwstart = 0; 4931 struct ia64_unw_aux_info aux; 4932 4933 memset (& aux, 0, sizeof (aux)); 4934 4935 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec) 4936 { 4937 if (sec->sh_type == SHT_SYMTAB 4938 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum) 4939 { 4940 aux.nsyms = sec->sh_size / sec->sh_entsize; 4941 aux.symtab = GET_ELF_SYMBOLS (file, sec); 4942 4943 strsec = SECTION_HEADER (sec->sh_link); 4944 aux.strtab = get_data (NULL, file, strsec->sh_offset, 4945 1, strsec->sh_size, _("string table")); 4946 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0; 4947 } 4948 else if (sec->sh_type == SHT_IA_64_UNWIND) 4949 unwcount++; 4950 } 4951 4952 if (!unwcount) 4953 printf (_("\nThere are no unwind sections in this file.\n")); 4954 4955 while (unwcount-- > 0) 4956 { 4957 char *suffix; 4958 size_t len, len2; 4959 4960 for (i = unwstart, sec = section_headers + unwstart; 4961 i < elf_header.e_shnum; ++i, ++sec) 4962 if (sec->sh_type == SHT_IA_64_UNWIND) 4963 { 4964 unwsec = sec; 4965 break; 4966 } 4967 4968 unwstart = i + 1; 4969 len = sizeof (ELF_STRING_ia64_unwind_once) - 1; 4970 4971 if ((unwsec->sh_flags & SHF_GROUP) != 0) 4972 { 4973 /* We need to find which section group it is in. */ 4974 struct group_list *g = section_headers_groups [i]->root; 4975 4976 for (; g != NULL; g = g->next) 4977 { 4978 sec = SECTION_HEADER (g->section_index); 4979 4980 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info)) 4981 break; 4982 } 4983 4984 if (g == NULL) 4985 i = elf_header.e_shnum; 4986 } 4987 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len)) 4988 { 4989 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */ 4990 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1; 4991 suffix = SECTION_NAME (unwsec) + len; 4992 for (i = 0, sec = section_headers; i < elf_header.e_shnum; 4993 ++i, ++sec) 4994 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2) 4995 && streq (SECTION_NAME (sec) + len2, suffix)) 4996 break; 4997 } 4998 else 4999 { 5000 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO 5001 .IA_64.unwind or BAR -> .IA_64.unwind_info. */ 5002 len = sizeof (ELF_STRING_ia64_unwind) - 1; 5003 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1; 5004 suffix = ""; 5005 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len)) 5006 suffix = SECTION_NAME (unwsec) + len; 5007 for (i = 0, sec = section_headers; i < elf_header.e_shnum; 5008 ++i, ++sec) 5009 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2) 5010 && streq (SECTION_NAME (sec) + len2, suffix)) 5011 break; 5012 } 5013 5014 if (i == elf_header.e_shnum) 5015 { 5016 printf (_("\nCould not find unwind info section for ")); 5017 5018 if (string_table == NULL) 5019 printf ("%d", unwsec->sh_name); 5020 else 5021 printf (_("'%s'"), SECTION_NAME (unwsec)); 5022 } 5023 else 5024 { 5025 aux.info_size = sec->sh_size; 5026 aux.info_addr = sec->sh_addr; 5027 aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size, 5028 _("unwind info")); 5029 5030 printf (_("\nUnwind section ")); 5031 5032 if (string_table == NULL) 5033 printf ("%d", unwsec->sh_name); 5034 else 5035 printf (_("'%s'"), SECTION_NAME (unwsec)); 5036 5037 printf (_(" at offset 0x%lx contains %lu entries:\n"), 5038 (unsigned long) unwsec->sh_offset, 5039 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size))); 5040 5041 (void) slurp_ia64_unwind_table (file, & aux, unwsec); 5042 5043 if (aux.table_len > 0) 5044 dump_ia64_unwind (& aux); 5045 5046 if (aux.table) 5047 free ((char *) aux.table); 5048 if (aux.info) 5049 free ((char *) aux.info); 5050 aux.table = NULL; 5051 aux.info = NULL; 5052 } 5053 } 5054 5055 if (aux.symtab) 5056 free (aux.symtab); 5057 if (aux.strtab) 5058 free ((char *) aux.strtab); 5059 5060 return 1; 5061 } 5062 5063 struct hppa_unw_aux_info 5064 { 5065 struct hppa_unw_table_entry 5066 { 5067 struct absaddr start; 5068 struct absaddr end; 5069 unsigned int Cannot_unwind:1; /* 0 */ 5070 unsigned int Millicode:1; /* 1 */ 5071 unsigned int Millicode_save_sr0:1; /* 2 */ 5072 unsigned int Region_description:2; /* 3..4 */ 5073 unsigned int reserved1:1; /* 5 */ 5074 unsigned int Entry_SR:1; /* 6 */ 5075 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */ 5076 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */ 5077 unsigned int Args_stored:1; /* 16 */ 5078 unsigned int Variable_Frame:1; /* 17 */ 5079 unsigned int Separate_Package_Body:1; /* 18 */ 5080 unsigned int Frame_Extension_Millicode:1; /* 19 */ 5081 unsigned int Stack_Overflow_Check:1; /* 20 */ 5082 unsigned int Two_Instruction_SP_Increment:1; /* 21 */ 5083 unsigned int Ada_Region:1; /* 22 */ 5084 unsigned int cxx_info:1; /* 23 */ 5085 unsigned int cxx_try_catch:1; /* 24 */ 5086 unsigned int sched_entry_seq:1; /* 25 */ 5087 unsigned int reserved2:1; /* 26 */ 5088 unsigned int Save_SP:1; /* 27 */ 5089 unsigned int Save_RP:1; /* 28 */ 5090 unsigned int Save_MRP_in_frame:1; /* 29 */ 5091 unsigned int extn_ptr_defined:1; /* 30 */ 5092 unsigned int Cleanup_defined:1; /* 31 */ 5093 5094 unsigned int MPE_XL_interrupt_marker:1; /* 0 */ 5095 unsigned int HP_UX_interrupt_marker:1; /* 1 */ 5096 unsigned int Large_frame:1; /* 2 */ 5097 unsigned int Pseudo_SP_Set:1; /* 3 */ 5098 unsigned int reserved4:1; /* 4 */ 5099 unsigned int Total_frame_size:27; /* 5..31 */ 5100 } 5101 *table; /* Unwind table. */ 5102 unsigned long table_len; /* Length of unwind table. */ 5103 bfd_vma seg_base; /* Starting address of segment. */ 5104 Elf_Internal_Sym *symtab; /* The symbol table. */ 5105 unsigned long nsyms; /* Number of symbols. */ 5106 char *strtab; /* The string table. */ 5107 unsigned long strtab_size; /* Size of string table. */ 5108 }; 5109 5110 static void 5111 dump_hppa_unwind (struct hppa_unw_aux_info *aux) 5112 { 5113 struct hppa_unw_table_entry *tp; 5114 5115 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp) 5116 { 5117 bfd_vma offset; 5118 const char *procname; 5119 5120 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab, 5121 aux->strtab_size, tp->start, &procname, 5122 &offset); 5123 5124 fputs ("\n<", stdout); 5125 5126 if (procname) 5127 { 5128 fputs (procname, stdout); 5129 5130 if (offset) 5131 printf ("+%lx", (unsigned long) offset); 5132 } 5133 5134 fputs (">: [", stdout); 5135 print_vma (tp->start.offset, PREFIX_HEX); 5136 fputc ('-', stdout); 5137 print_vma (tp->end.offset, PREFIX_HEX); 5138 printf ("]\n\t"); 5139 5140 #define PF(_m) if (tp->_m) printf (#_m " "); 5141 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m); 5142 PF(Cannot_unwind); 5143 PF(Millicode); 5144 PF(Millicode_save_sr0); 5145 /* PV(Region_description); */ 5146 PF(Entry_SR); 5147 PV(Entry_FR); 5148 PV(Entry_GR); 5149 PF(Args_stored); 5150 PF(Variable_Frame); 5151 PF(Separate_Package_Body); 5152 PF(Frame_Extension_Millicode); 5153 PF(Stack_Overflow_Check); 5154 PF(Two_Instruction_SP_Increment); 5155 PF(Ada_Region); 5156 PF(cxx_info); 5157 PF(cxx_try_catch); 5158 PF(sched_entry_seq); 5159 PF(Save_SP); 5160 PF(Save_RP); 5161 PF(Save_MRP_in_frame); 5162 PF(extn_ptr_defined); 5163 PF(Cleanup_defined); 5164 PF(MPE_XL_interrupt_marker); 5165 PF(HP_UX_interrupt_marker); 5166 PF(Large_frame); 5167 PF(Pseudo_SP_Set); 5168 PV(Total_frame_size); 5169 #undef PF 5170 #undef PV 5171 } 5172 5173 printf ("\n"); 5174 } 5175 5176 static int 5177 slurp_hppa_unwind_table (FILE *file, 5178 struct hppa_unw_aux_info *aux, 5179 Elf_Internal_Shdr *sec) 5180 { 5181 unsigned long size, unw_ent_size, nentries, nrelas, i; 5182 Elf_Internal_Phdr *seg; 5183 struct hppa_unw_table_entry *tep; 5184 Elf_Internal_Shdr *relsec; 5185 Elf_Internal_Rela *rela, *rp; 5186 unsigned char *table, *tp; 5187 Elf_Internal_Sym *sym; 5188 const char *relname; 5189 5190 /* First, find the starting address of the segment that includes 5191 this section. */ 5192 5193 if (elf_header.e_phnum) 5194 { 5195 if (! get_program_headers (file)) 5196 return 0; 5197 5198 for (seg = program_headers; 5199 seg < program_headers + elf_header.e_phnum; 5200 ++seg) 5201 { 5202 if (seg->p_type != PT_LOAD) 5203 continue; 5204 5205 if (sec->sh_addr >= seg->p_vaddr 5206 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz)) 5207 { 5208 aux->seg_base = seg->p_vaddr; 5209 break; 5210 } 5211 } 5212 } 5213 5214 /* Second, build the unwind table from the contents of the unwind 5215 section. */ 5216 size = sec->sh_size; 5217 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table")); 5218 if (!table) 5219 return 0; 5220 5221 unw_ent_size = 16; 5222 nentries = size / unw_ent_size; 5223 size = unw_ent_size * nentries; 5224 5225 tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0])); 5226 5227 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep) 5228 { 5229 unsigned int tmp1, tmp2; 5230 5231 tep->start.section = SHN_UNDEF; 5232 tep->end.section = SHN_UNDEF; 5233 5234 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4); 5235 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4); 5236 tmp1 = byte_get ((unsigned char *) tp + 8, 4); 5237 tmp2 = byte_get ((unsigned char *) tp + 12, 4); 5238 5239 tep->start.offset += aux->seg_base; 5240 tep->end.offset += aux->seg_base; 5241 5242 tep->Cannot_unwind = (tmp1 >> 31) & 0x1; 5243 tep->Millicode = (tmp1 >> 30) & 0x1; 5244 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1; 5245 tep->Region_description = (tmp1 >> 27) & 0x3; 5246 tep->reserved1 = (tmp1 >> 26) & 0x1; 5247 tep->Entry_SR = (tmp1 >> 25) & 0x1; 5248 tep->Entry_FR = (tmp1 >> 21) & 0xf; 5249 tep->Entry_GR = (tmp1 >> 16) & 0x1f; 5250 tep->Args_stored = (tmp1 >> 15) & 0x1; 5251 tep->Variable_Frame = (tmp1 >> 14) & 0x1; 5252 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1; 5253 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1; 5254 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1; 5255 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1; 5256 tep->Ada_Region = (tmp1 >> 9) & 0x1; 5257 tep->cxx_info = (tmp1 >> 8) & 0x1; 5258 tep->cxx_try_catch = (tmp1 >> 7) & 0x1; 5259 tep->sched_entry_seq = (tmp1 >> 6) & 0x1; 5260 tep->reserved2 = (tmp1 >> 5) & 0x1; 5261 tep->Save_SP = (tmp1 >> 4) & 0x1; 5262 tep->Save_RP = (tmp1 >> 3) & 0x1; 5263 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1; 5264 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1; 5265 tep->Cleanup_defined = tmp1 & 0x1; 5266 5267 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1; 5268 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1; 5269 tep->Large_frame = (tmp2 >> 29) & 0x1; 5270 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1; 5271 tep->reserved4 = (tmp2 >> 27) & 0x1; 5272 tep->Total_frame_size = tmp2 & 0x7ffffff; 5273 } 5274 free (table); 5275 5276 /* Third, apply any relocations to the unwind table. */ 5277 5278 for (relsec = section_headers; 5279 relsec < section_headers + elf_header.e_shnum; 5280 ++relsec) 5281 { 5282 if (relsec->sh_type != SHT_RELA 5283 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum 5284 || SECTION_HEADER (relsec->sh_info) != sec) 5285 continue; 5286 5287 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size, 5288 & rela, & nrelas)) 5289 return 0; 5290 5291 for (rp = rela; rp < rela + nrelas; ++rp) 5292 { 5293 if (is_32bit_elf) 5294 { 5295 relname = elf_hppa_reloc_type (ELF32_R_TYPE (rp->r_info)); 5296 sym = aux->symtab + ELF32_R_SYM (rp->r_info); 5297 } 5298 else 5299 { 5300 relname = elf_hppa_reloc_type (ELF64_R_TYPE (rp->r_info)); 5301 sym = aux->symtab + ELF64_R_SYM (rp->r_info); 5302 } 5303 5304 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */ 5305 if (strncmp (relname, "R_PARISC_SEGREL", 15) != 0) 5306 { 5307 warn (_("Skipping unexpected relocation type %s\n"), relname); 5308 continue; 5309 } 5310 5311 i = rp->r_offset / unw_ent_size; 5312 5313 switch ((rp->r_offset % unw_ent_size) / eh_addr_size) 5314 { 5315 case 0: 5316 aux->table[i].start.section = sym->st_shndx; 5317 aux->table[i].start.offset += sym->st_value + rp->r_addend; 5318 break; 5319 case 1: 5320 aux->table[i].end.section = sym->st_shndx; 5321 aux->table[i].end.offset += sym->st_value + rp->r_addend; 5322 break; 5323 default: 5324 break; 5325 } 5326 } 5327 5328 free (rela); 5329 } 5330 5331 aux->table_len = nentries; 5332 5333 return 1; 5334 } 5335 5336 static int 5337 hppa_process_unwind (FILE *file) 5338 { 5339 struct hppa_unw_aux_info aux; 5340 Elf_Internal_Shdr *unwsec = NULL; 5341 Elf_Internal_Shdr *strsec; 5342 Elf_Internal_Shdr *sec; 5343 unsigned long i; 5344 5345 memset (& aux, 0, sizeof (aux)); 5346 5347 if (string_table == NULL) 5348 return 1; 5349 5350 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec) 5351 { 5352 if (sec->sh_type == SHT_SYMTAB 5353 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum) 5354 { 5355 aux.nsyms = sec->sh_size / sec->sh_entsize; 5356 aux.symtab = GET_ELF_SYMBOLS (file, sec); 5357 5358 strsec = SECTION_HEADER (sec->sh_link); 5359 aux.strtab = get_data (NULL, file, strsec->sh_offset, 5360 1, strsec->sh_size, _("string table")); 5361 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0; 5362 } 5363 else if (streq (SECTION_NAME (sec), ".PARISC.unwind")) 5364 unwsec = sec; 5365 } 5366 5367 if (!unwsec) 5368 printf (_("\nThere are no unwind sections in this file.\n")); 5369 5370 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec) 5371 { 5372 if (streq (SECTION_NAME (sec), ".PARISC.unwind")) 5373 { 5374 printf (_("\nUnwind section ")); 5375 printf (_("'%s'"), SECTION_NAME (sec)); 5376 5377 printf (_(" at offset 0x%lx contains %lu entries:\n"), 5378 (unsigned long) sec->sh_offset, 5379 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8))); 5380 5381 slurp_hppa_unwind_table (file, &aux, sec); 5382 if (aux.table_len > 0) 5383 dump_hppa_unwind (&aux); 5384 5385 if (aux.table) 5386 free ((char *) aux.table); 5387 aux.table = NULL; 5388 } 5389 } 5390 5391 if (aux.symtab) 5392 free (aux.symtab); 5393 if (aux.strtab) 5394 free ((char *) aux.strtab); 5395 5396 return 1; 5397 } 5398 5399 static int 5400 process_unwind (FILE *file) 5401 { 5402 struct unwind_handler { 5403 int machtype; 5404 int (*handler)(FILE *file); 5405 } handlers[] = { 5406 { EM_IA_64, ia64_process_unwind }, 5407 { EM_PARISC, hppa_process_unwind }, 5408 { 0, 0 } 5409 }; 5410 int i; 5411 5412 if (!do_unwind) 5413 return 1; 5414 5415 for (i = 0; handlers[i].handler != NULL; i++) 5416 if (elf_header.e_machine == handlers[i].machtype) 5417 return handlers[i].handler (file); 5418 5419 printf (_("\nThere are no unwind sections in this file.\n")); 5420 return 1; 5421 } 5422 5423 static void 5424 dynamic_section_mips_val (Elf_Internal_Dyn *entry) 5425 { 5426 switch (entry->d_tag) 5427 { 5428 case DT_MIPS_FLAGS: 5429 if (entry->d_un.d_val == 0) 5430 printf ("NONE\n"); 5431 else 5432 { 5433 static const char * opts[] = 5434 { 5435 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT", 5436 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS", 5437 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD", 5438 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF", 5439 "RLD_ORDER_SAFE" 5440 }; 5441 unsigned int cnt; 5442 int first = 1; 5443 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt) 5444 if (entry->d_un.d_val & (1 << cnt)) 5445 { 5446 printf ("%s%s", first ? "" : " ", opts[cnt]); 5447 first = 0; 5448 } 5449 puts (""); 5450 } 5451 break; 5452 5453 case DT_MIPS_IVERSION: 5454 if (VALID_DYNAMIC_NAME (entry->d_un.d_val)) 5455 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val)); 5456 else 5457 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr); 5458 break; 5459 5460 case DT_MIPS_TIME_STAMP: 5461 { 5462 char timebuf[20]; 5463 struct tm *tmp; 5464 5465 time_t time = entry->d_un.d_val; 5466 tmp = gmtime (&time); 5467 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u", 5468 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, 5469 tmp->tm_hour, tmp->tm_min, tmp->tm_sec); 5470 printf ("Time Stamp: %s\n", timebuf); 5471 } 5472 break; 5473 5474 case DT_MIPS_RLD_VERSION: 5475 case DT_MIPS_LOCAL_GOTNO: 5476 case DT_MIPS_CONFLICTNO: 5477 case DT_MIPS_LIBLISTNO: 5478 case DT_MIPS_SYMTABNO: 5479 case DT_MIPS_UNREFEXTNO: 5480 case DT_MIPS_HIPAGENO: 5481 case DT_MIPS_DELTA_CLASS_NO: 5482 case DT_MIPS_DELTA_INSTANCE_NO: 5483 case DT_MIPS_DELTA_RELOC_NO: 5484 case DT_MIPS_DELTA_SYM_NO: 5485 case DT_MIPS_DELTA_CLASSSYM_NO: 5486 case DT_MIPS_COMPACT_SIZE: 5487 printf ("%ld\n", (long) entry->d_un.d_ptr); 5488 break; 5489 5490 default: 5491 printf ("%#lx\n", (long) entry->d_un.d_ptr); 5492 } 5493 } 5494 5495 5496 static void 5497 dynamic_section_parisc_val (Elf_Internal_Dyn *entry) 5498 { 5499 switch (entry->d_tag) 5500 { 5501 case DT_HP_DLD_FLAGS: 5502 { 5503 static struct 5504 { 5505 long int bit; 5506 const char *str; 5507 } 5508 flags[] = 5509 { 5510 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" }, 5511 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" }, 5512 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" }, 5513 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" }, 5514 { DT_HP_BIND_NOW, "HP_BIND_NOW" }, 5515 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" }, 5516 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" }, 5517 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" }, 5518 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" }, 5519 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" }, 5520 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }, 5521 { DT_HP_GST, "HP_GST" }, 5522 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" }, 5523 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" }, 5524 { DT_HP_NODELETE, "HP_NODELETE" }, 5525 { DT_HP_GROUP, "HP_GROUP" }, 5526 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" } 5527 }; 5528 int first = 1; 5529 size_t cnt; 5530 bfd_vma val = entry->d_un.d_val; 5531 5532 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt) 5533 if (val & flags[cnt].bit) 5534 { 5535 if (! first) 5536 putchar (' '); 5537 fputs (flags[cnt].str, stdout); 5538 first = 0; 5539 val ^= flags[cnt].bit; 5540 } 5541 5542 if (val != 0 || first) 5543 { 5544 if (! first) 5545 putchar (' '); 5546 print_vma (val, HEX); 5547 } 5548 } 5549 break; 5550 5551 default: 5552 print_vma (entry->d_un.d_ptr, PREFIX_HEX); 5553 break; 5554 } 5555 putchar ('\n'); 5556 } 5557 5558 static void 5559 dynamic_section_ia64_val (Elf_Internal_Dyn *entry) 5560 { 5561 switch (entry->d_tag) 5562 { 5563 case DT_IA_64_PLT_RESERVE: 5564 /* First 3 slots reserved. */ 5565 print_vma (entry->d_un.d_ptr, PREFIX_HEX); 5566 printf (" -- "); 5567 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX); 5568 break; 5569 5570 default: 5571 print_vma (entry->d_un.d_ptr, PREFIX_HEX); 5572 break; 5573 } 5574 putchar ('\n'); 5575 } 5576 5577 static int 5578 get_32bit_dynamic_section (FILE *file) 5579 { 5580 Elf32_External_Dyn *edyn, *ext; 5581 Elf_Internal_Dyn *entry; 5582 5583 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size, 5584 _("dynamic section")); 5585 if (!edyn) 5586 return 0; 5587 5588 /* SGI's ELF has more than one section in the DYNAMIC segment, and we 5589 might not have the luxury of section headers. Look for the DT_NULL 5590 terminator to determine the number of entries. */ 5591 for (ext = edyn, dynamic_nent = 0; 5592 (char *) ext < (char *) edyn + dynamic_size; 5593 ext++) 5594 { 5595 dynamic_nent++; 5596 if (BYTE_GET (ext->d_tag) == DT_NULL) 5597 break; 5598 } 5599 5600 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry)); 5601 if (dynamic_section == NULL) 5602 { 5603 error (_("Out of memory\n")); 5604 free (edyn); 5605 return 0; 5606 } 5607 5608 for (ext = edyn, entry = dynamic_section; 5609 entry < dynamic_section + dynamic_nent; 5610 ext++, entry++) 5611 { 5612 entry->d_tag = BYTE_GET (ext->d_tag); 5613 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val); 5614 } 5615 5616 free (edyn); 5617 5618 return 1; 5619 } 5620 5621 static int 5622 get_64bit_dynamic_section (FILE *file) 5623 { 5624 Elf64_External_Dyn *edyn, *ext; 5625 Elf_Internal_Dyn *entry; 5626 5627 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size, 5628 _("dynamic section")); 5629 if (!edyn) 5630 return 0; 5631 5632 /* SGI's ELF has more than one section in the DYNAMIC segment, and we 5633 might not have the luxury of section headers. Look for the DT_NULL 5634 terminator to determine the number of entries. */ 5635 for (ext = edyn, dynamic_nent = 0; 5636 (char *) ext < (char *) edyn + dynamic_size; 5637 ext++) 5638 { 5639 dynamic_nent++; 5640 if (BYTE_GET (ext->d_tag) == DT_NULL) 5641 break; 5642 } 5643 5644 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry)); 5645 if (dynamic_section == NULL) 5646 { 5647 error (_("Out of memory\n")); 5648 free (edyn); 5649 return 0; 5650 } 5651 5652 for (ext = edyn, entry = dynamic_section; 5653 entry < dynamic_section + dynamic_nent; 5654 ext++, entry++) 5655 { 5656 entry->d_tag = BYTE_GET (ext->d_tag); 5657 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val); 5658 } 5659 5660 free (edyn); 5661 5662 return 1; 5663 } 5664 5665 static void 5666 print_dynamic_flags (bfd_vma flags) 5667 { 5668 int first = 1; 5669 5670 while (flags) 5671 { 5672 bfd_vma flag; 5673 5674 flag = flags & - flags; 5675 flags &= ~ flag; 5676 5677 if (first) 5678 first = 0; 5679 else 5680 putc (' ', stdout); 5681 5682 switch (flag) 5683 { 5684 case DF_ORIGIN: fputs ("ORIGIN", stdout); break; 5685 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break; 5686 case DF_TEXTREL: fputs ("TEXTREL", stdout); break; 5687 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break; 5688 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break; 5689 default: fputs ("unknown", stdout); break; 5690 } 5691 } 5692 puts (""); 5693 } 5694 5695 /* Parse and display the contents of the dynamic section. */ 5696 5697 static int 5698 process_dynamic_section (FILE *file) 5699 { 5700 Elf_Internal_Dyn *entry; 5701 5702 if (dynamic_size == 0) 5703 { 5704 if (do_dynamic) 5705 printf (_("\nThere is no dynamic section in this file.\n")); 5706 5707 return 1; 5708 } 5709 5710 if (is_32bit_elf) 5711 { 5712 if (! get_32bit_dynamic_section (file)) 5713 return 0; 5714 } 5715 else if (! get_64bit_dynamic_section (file)) 5716 return 0; 5717 5718 /* Find the appropriate symbol table. */ 5719 if (dynamic_symbols == NULL) 5720 { 5721 for (entry = dynamic_section; 5722 entry < dynamic_section + dynamic_nent; 5723 ++entry) 5724 { 5725 Elf_Internal_Shdr section; 5726 5727 if (entry->d_tag != DT_SYMTAB) 5728 continue; 5729 5730 dynamic_info[DT_SYMTAB] = entry->d_un.d_val; 5731 5732 /* Since we do not know how big the symbol table is, 5733 we default to reading in the entire file (!) and 5734 processing that. This is overkill, I know, but it 5735 should work. */ 5736 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0); 5737 5738 if (archive_file_offset != 0) 5739 section.sh_size = archive_file_size - section.sh_offset; 5740 else 5741 { 5742 if (fseek (file, 0, SEEK_END)) 5743 error (_("Unable to seek to end of file!")); 5744 5745 section.sh_size = ftell (file) - section.sh_offset; 5746 } 5747 5748 if (is_32bit_elf) 5749 section.sh_entsize = sizeof (Elf32_External_Sym); 5750 else 5751 section.sh_entsize = sizeof (Elf64_External_Sym); 5752 5753 num_dynamic_syms = section.sh_size / section.sh_entsize; 5754 if (num_dynamic_syms < 1) 5755 { 5756 error (_("Unable to determine the number of symbols to load\n")); 5757 continue; 5758 } 5759 5760 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion); 5761 } 5762 } 5763 5764 /* Similarly find a string table. */ 5765 if (dynamic_strings == NULL) 5766 { 5767 for (entry = dynamic_section; 5768 entry < dynamic_section + dynamic_nent; 5769 ++entry) 5770 { 5771 unsigned long offset; 5772 long str_tab_len; 5773 5774 if (entry->d_tag != DT_STRTAB) 5775 continue; 5776 5777 dynamic_info[DT_STRTAB] = entry->d_un.d_val; 5778 5779 /* Since we do not know how big the string table is, 5780 we default to reading in the entire file (!) and 5781 processing that. This is overkill, I know, but it 5782 should work. */ 5783 5784 offset = offset_from_vma (file, entry->d_un.d_val, 0); 5785 5786 if (archive_file_offset != 0) 5787 str_tab_len = archive_file_size - offset; 5788 else 5789 { 5790 if (fseek (file, 0, SEEK_END)) 5791 error (_("Unable to seek to end of file\n")); 5792 str_tab_len = ftell (file) - offset; 5793 } 5794 5795 if (str_tab_len < 1) 5796 { 5797 error 5798 (_("Unable to determine the length of the dynamic string table\n")); 5799 continue; 5800 } 5801 5802 dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len, 5803 _("dynamic string table")); 5804 dynamic_strings_length = str_tab_len; 5805 break; 5806 } 5807 } 5808 5809 /* And find the syminfo section if available. */ 5810 if (dynamic_syminfo == NULL) 5811 { 5812 unsigned long syminsz = 0; 5813 5814 for (entry = dynamic_section; 5815 entry < dynamic_section + dynamic_nent; 5816 ++entry) 5817 { 5818 if (entry->d_tag == DT_SYMINENT) 5819 { 5820 /* Note: these braces are necessary to avoid a syntax 5821 error from the SunOS4 C compiler. */ 5822 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val); 5823 } 5824 else if (entry->d_tag == DT_SYMINSZ) 5825 syminsz = entry->d_un.d_val; 5826 else if (entry->d_tag == DT_SYMINFO) 5827 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val, 5828 syminsz); 5829 } 5830 5831 if (dynamic_syminfo_offset != 0 && syminsz != 0) 5832 { 5833 Elf_External_Syminfo *extsyminfo, *extsym; 5834 Elf_Internal_Syminfo *syminfo; 5835 5836 /* There is a syminfo section. Read the data. */ 5837 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1, 5838 syminsz, _("symbol information")); 5839 if (!extsyminfo) 5840 return 0; 5841 5842 dynamic_syminfo = malloc (syminsz); 5843 if (dynamic_syminfo == NULL) 5844 { 5845 error (_("Out of memory\n")); 5846 return 0; 5847 } 5848 5849 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo); 5850 for (syminfo = dynamic_syminfo, extsym = extsyminfo; 5851 syminfo < dynamic_syminfo + dynamic_syminfo_nent; 5852 ++syminfo, ++extsym) 5853 { 5854 syminfo->si_boundto = BYTE_GET (extsym->si_boundto); 5855 syminfo->si_flags = BYTE_GET (extsym->si_flags); 5856 } 5857 5858 free (extsyminfo); 5859 } 5860 } 5861 5862 if (do_dynamic && dynamic_addr) 5863 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"), 5864 dynamic_addr, dynamic_nent); 5865 if (do_dynamic) 5866 printf (_(" Tag Type Name/Value\n")); 5867 5868 for (entry = dynamic_section; 5869 entry < dynamic_section + dynamic_nent; 5870 entry++) 5871 { 5872 if (do_dynamic) 5873 { 5874 const char *dtype; 5875 5876 putchar (' '); 5877 print_vma (entry->d_tag, FULL_HEX); 5878 dtype = get_dynamic_type (entry->d_tag); 5879 printf (" (%s)%*s", dtype, 5880 ((is_32bit_elf ? 27 : 19) 5881 - (int) strlen (dtype)), 5882 " "); 5883 } 5884 5885 switch (entry->d_tag) 5886 { 5887 case DT_FLAGS: 5888 if (do_dynamic) 5889 print_dynamic_flags (entry->d_un.d_val); 5890 break; 5891 5892 case DT_AUXILIARY: 5893 case DT_FILTER: 5894 case DT_CONFIG: 5895 case DT_DEPAUDIT: 5896 case DT_AUDIT: 5897 if (do_dynamic) 5898 { 5899 switch (entry->d_tag) 5900 { 5901 case DT_AUXILIARY: 5902 printf (_("Auxiliary library")); 5903 break; 5904 5905 case DT_FILTER: 5906 printf (_("Filter library")); 5907 break; 5908 5909 case DT_CONFIG: 5910 printf (_("Configuration file")); 5911 break; 5912 5913 case DT_DEPAUDIT: 5914 printf (_("Dependency audit library")); 5915 break; 5916 5917 case DT_AUDIT: 5918 printf (_("Audit library")); 5919 break; 5920 } 5921 5922 if (VALID_DYNAMIC_NAME (entry->d_un.d_val)) 5923 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val)); 5924 else 5925 { 5926 printf (": "); 5927 print_vma (entry->d_un.d_val, PREFIX_HEX); 5928 putchar ('\n'); 5929 } 5930 } 5931 break; 5932 5933 case DT_FEATURE: 5934 if (do_dynamic) 5935 { 5936 printf (_("Flags:")); 5937 5938 if (entry->d_un.d_val == 0) 5939 printf (_(" None\n")); 5940 else 5941 { 5942 unsigned long int val = entry->d_un.d_val; 5943 5944 if (val & DTF_1_PARINIT) 5945 { 5946 printf (" PARINIT"); 5947 val ^= DTF_1_PARINIT; 5948 } 5949 if (val & DTF_1_CONFEXP) 5950 { 5951 printf (" CONFEXP"); 5952 val ^= DTF_1_CONFEXP; 5953 } 5954 if (val != 0) 5955 printf (" %lx", val); 5956 puts (""); 5957 } 5958 } 5959 break; 5960 5961 case DT_POSFLAG_1: 5962 if (do_dynamic) 5963 { 5964 printf (_("Flags:")); 5965 5966 if (entry->d_un.d_val == 0) 5967 printf (_(" None\n")); 5968 else 5969 { 5970 unsigned long int val = entry->d_un.d_val; 5971 5972 if (val & DF_P1_LAZYLOAD) 5973 { 5974 printf (" LAZYLOAD"); 5975 val ^= DF_P1_LAZYLOAD; 5976 } 5977 if (val & DF_P1_GROUPPERM) 5978 { 5979 printf (" GROUPPERM"); 5980 val ^= DF_P1_GROUPPERM; 5981 } 5982 if (val != 0) 5983 printf (" %lx", val); 5984 puts (""); 5985 } 5986 } 5987 break; 5988 5989 case DT_FLAGS_1: 5990 if (do_dynamic) 5991 { 5992 printf (_("Flags:")); 5993 if (entry->d_un.d_val == 0) 5994 printf (_(" None\n")); 5995 else 5996 { 5997 unsigned long int val = entry->d_un.d_val; 5998 5999 if (val & DF_1_NOW) 6000 { 6001 printf (" NOW"); 6002 val ^= DF_1_NOW; 6003 } 6004 if (val & DF_1_GLOBAL) 6005 { 6006 printf (" GLOBAL"); 6007 val ^= DF_1_GLOBAL; 6008 } 6009 if (val & DF_1_GROUP) 6010 { 6011 printf (" GROUP"); 6012 val ^= DF_1_GROUP; 6013 } 6014 if (val & DF_1_NODELETE) 6015 { 6016 printf (" NODELETE"); 6017 val ^= DF_1_NODELETE; 6018 } 6019 if (val & DF_1_LOADFLTR) 6020 { 6021 printf (" LOADFLTR"); 6022 val ^= DF_1_LOADFLTR; 6023 } 6024 if (val & DF_1_INITFIRST) 6025 { 6026 printf (" INITFIRST"); 6027 val ^= DF_1_INITFIRST; 6028 } 6029 if (val & DF_1_NOOPEN) 6030 { 6031 printf (" NOOPEN"); 6032 val ^= DF_1_NOOPEN; 6033 } 6034 if (val & DF_1_ORIGIN) 6035 { 6036 printf (" ORIGIN"); 6037 val ^= DF_1_ORIGIN; 6038 } 6039 if (val & DF_1_DIRECT) 6040 { 6041 printf (" DIRECT"); 6042 val ^= DF_1_DIRECT; 6043 } 6044 if (val & DF_1_TRANS) 6045 { 6046 printf (" TRANS"); 6047 val ^= DF_1_TRANS; 6048 } 6049 if (val & DF_1_INTERPOSE) 6050 { 6051 printf (" INTERPOSE"); 6052 val ^= DF_1_INTERPOSE; 6053 } 6054 if (val & DF_1_NODEFLIB) 6055 { 6056 printf (" NODEFLIB"); 6057 val ^= DF_1_NODEFLIB; 6058 } 6059 if (val & DF_1_NODUMP) 6060 { 6061 printf (" NODUMP"); 6062 val ^= DF_1_NODUMP; 6063 } 6064 if (val & DF_1_CONLFAT) 6065 { 6066 printf (" CONLFAT"); 6067 val ^= DF_1_CONLFAT; 6068 } 6069 if (val != 0) 6070 printf (" %lx", val); 6071 puts (""); 6072 } 6073 } 6074 break; 6075 6076 case DT_PLTREL: 6077 dynamic_info[entry->d_tag] = entry->d_un.d_val; 6078 if (do_dynamic) 6079 puts (get_dynamic_type (entry->d_un.d_val)); 6080 break; 6081 6082 case DT_NULL : 6083 case DT_NEEDED : 6084 case DT_PLTGOT : 6085 case DT_HASH : 6086 case DT_STRTAB : 6087 case DT_SYMTAB : 6088 case DT_RELA : 6089 case DT_INIT : 6090 case DT_FINI : 6091 case DT_SONAME : 6092 case DT_RPATH : 6093 case DT_SYMBOLIC: 6094 case DT_REL : 6095 case DT_DEBUG : 6096 case DT_TEXTREL : 6097 case DT_JMPREL : 6098 case DT_RUNPATH : 6099 dynamic_info[entry->d_tag] = entry->d_un.d_val; 6100 6101 if (do_dynamic) 6102 { 6103 char *name; 6104 6105 if (VALID_DYNAMIC_NAME (entry->d_un.d_val)) 6106 name = GET_DYNAMIC_NAME (entry->d_un.d_val); 6107 else 6108 name = NULL; 6109 6110 if (name) 6111 { 6112 switch (entry->d_tag) 6113 { 6114 case DT_NEEDED: 6115 printf (_("Shared library: [%s]"), name); 6116 6117 if (streq (name, program_interpreter)) 6118 printf (_(" program interpreter")); 6119 break; 6120 6121 case DT_SONAME: 6122 printf (_("Library soname: [%s]"), name); 6123 break; 6124 6125 case DT_RPATH: 6126 printf (_("Library rpath: [%s]"), name); 6127 break; 6128 6129 case DT_RUNPATH: 6130 printf (_("Library runpath: [%s]"), name); 6131 break; 6132 6133 default: 6134 print_vma (entry->d_un.d_val, PREFIX_HEX); 6135 break; 6136 } 6137 } 6138 else 6139 print_vma (entry->d_un.d_val, PREFIX_HEX); 6140 6141 putchar ('\n'); 6142 } 6143 break; 6144 6145 case DT_PLTRELSZ: 6146 case DT_RELASZ : 6147 case DT_STRSZ : 6148 case DT_RELSZ : 6149 case DT_RELAENT : 6150 case DT_SYMENT : 6151 case DT_RELENT : 6152 dynamic_info[entry->d_tag] = entry->d_un.d_val; 6153 case DT_PLTPADSZ: 6154 case DT_MOVEENT : 6155 case DT_MOVESZ : 6156 case DT_INIT_ARRAYSZ: 6157 case DT_FINI_ARRAYSZ: 6158 case DT_GNU_CONFLICTSZ: 6159 case DT_GNU_LIBLISTSZ: 6160 if (do_dynamic) 6161 { 6162 print_vma (entry->d_un.d_val, UNSIGNED); 6163 printf (" (bytes)\n"); 6164 } 6165 break; 6166 6167 case DT_VERDEFNUM: 6168 case DT_VERNEEDNUM: 6169 case DT_RELACOUNT: 6170 case DT_RELCOUNT: 6171 if (do_dynamic) 6172 { 6173 print_vma (entry->d_un.d_val, UNSIGNED); 6174 putchar ('\n'); 6175 } 6176 break; 6177 6178 case DT_SYMINSZ: 6179 case DT_SYMINENT: 6180 case DT_SYMINFO: 6181 case DT_USED: 6182 case DT_INIT_ARRAY: 6183 case DT_FINI_ARRAY: 6184 if (do_dynamic) 6185 { 6186 if (entry->d_tag == DT_USED 6187 && VALID_DYNAMIC_NAME (entry->d_un.d_val)) 6188 { 6189 char *name = GET_DYNAMIC_NAME (entry->d_un.d_val); 6190 6191 if (*name) 6192 { 6193 printf (_("Not needed object: [%s]\n"), name); 6194 break; 6195 } 6196 } 6197 6198 print_vma (entry->d_un.d_val, PREFIX_HEX); 6199 putchar ('\n'); 6200 } 6201 break; 6202 6203 case DT_BIND_NOW: 6204 /* The value of this entry is ignored. */ 6205 if (do_dynamic) 6206 putchar ('\n'); 6207 break; 6208 6209 case DT_GNU_PRELINKED: 6210 if (do_dynamic) 6211 { 6212 struct tm *tmp; 6213 time_t time = entry->d_un.d_val; 6214 6215 tmp = gmtime (&time); 6216 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n", 6217 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, 6218 tmp->tm_hour, tmp->tm_min, tmp->tm_sec); 6219 6220 } 6221 break; 6222 6223 default: 6224 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM)) 6225 version_info[DT_VERSIONTAGIDX (entry->d_tag)] = 6226 entry->d_un.d_val; 6227 6228 if (do_dynamic) 6229 { 6230 switch (elf_header.e_machine) 6231 { 6232 case EM_MIPS: 6233 case EM_MIPS_RS3_LE: 6234 dynamic_section_mips_val (entry); 6235 break; 6236 case EM_PARISC: 6237 dynamic_section_parisc_val (entry); 6238 break; 6239 case EM_IA_64: 6240 dynamic_section_ia64_val (entry); 6241 break; 6242 default: 6243 print_vma (entry->d_un.d_val, PREFIX_HEX); 6244 putchar ('\n'); 6245 } 6246 } 6247 break; 6248 } 6249 } 6250 6251 return 1; 6252 } 6253 6254 static char * 6255 get_ver_flags (unsigned int flags) 6256 { 6257 static char buff[32]; 6258 6259 buff[0] = 0; 6260 6261 if (flags == 0) 6262 return _("none"); 6263 6264 if (flags & VER_FLG_BASE) 6265 strcat (buff, "BASE "); 6266 6267 if (flags & VER_FLG_WEAK) 6268 { 6269 if (flags & VER_FLG_BASE) 6270 strcat (buff, "| "); 6271 6272 strcat (buff, "WEAK "); 6273 } 6274 6275 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK)) 6276 strcat (buff, "| <unknown>"); 6277 6278 return buff; 6279 } 6280 6281 /* Display the contents of the version sections. */ 6282 static int 6283 process_version_sections (FILE *file) 6284 { 6285 Elf_Internal_Shdr *section; 6286 unsigned i; 6287 int found = 0; 6288 6289 if (! do_version) 6290 return 1; 6291 6292 for (i = 0, section = section_headers; 6293 i < elf_header.e_shnum; 6294 i++, section++) 6295 { 6296 switch (section->sh_type) 6297 { 6298 case SHT_GNU_verdef: 6299 { 6300 Elf_External_Verdef *edefs; 6301 unsigned int idx; 6302 unsigned int cnt; 6303 6304 found = 1; 6305 6306 printf 6307 (_("\nVersion definition section '%s' contains %ld entries:\n"), 6308 SECTION_NAME (section), section->sh_info); 6309 6310 printf (_(" Addr: 0x")); 6311 printf_vma (section->sh_addr); 6312 printf (_(" Offset: %#08lx Link: %lx (%s)\n"), 6313 (unsigned long) section->sh_offset, section->sh_link, 6314 SECTION_HEADER_INDEX (section->sh_link) 6315 < elf_header.e_shnum 6316 ? SECTION_NAME (SECTION_HEADER (section->sh_link)) 6317 : "<corrupt>"); 6318 6319 edefs = get_data (NULL, file, section->sh_offset, 1, 6320 section->sh_size, 6321 _("version definition section")); 6322 if (!edefs) 6323 break; 6324 6325 for (idx = cnt = 0; cnt < section->sh_info; ++cnt) 6326 { 6327 char *vstart; 6328 Elf_External_Verdef *edef; 6329 Elf_Internal_Verdef ent; 6330 Elf_External_Verdaux *eaux; 6331 Elf_Internal_Verdaux aux; 6332 int j; 6333 int isum; 6334 6335 vstart = ((char *) edefs) + idx; 6336 6337 edef = (Elf_External_Verdef *) vstart; 6338 6339 ent.vd_version = BYTE_GET (edef->vd_version); 6340 ent.vd_flags = BYTE_GET (edef->vd_flags); 6341 ent.vd_ndx = BYTE_GET (edef->vd_ndx); 6342 ent.vd_cnt = BYTE_GET (edef->vd_cnt); 6343 ent.vd_hash = BYTE_GET (edef->vd_hash); 6344 ent.vd_aux = BYTE_GET (edef->vd_aux); 6345 ent.vd_next = BYTE_GET (edef->vd_next); 6346 6347 printf (_(" %#06x: Rev: %d Flags: %s"), 6348 idx, ent.vd_version, get_ver_flags (ent.vd_flags)); 6349 6350 printf (_(" Index: %d Cnt: %d "), 6351 ent.vd_ndx, ent.vd_cnt); 6352 6353 vstart += ent.vd_aux; 6354 6355 eaux = (Elf_External_Verdaux *) vstart; 6356 6357 aux.vda_name = BYTE_GET (eaux->vda_name); 6358 aux.vda_next = BYTE_GET (eaux->vda_next); 6359 6360 if (VALID_DYNAMIC_NAME (aux.vda_name)) 6361 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name)); 6362 else 6363 printf (_("Name index: %ld\n"), aux.vda_name); 6364 6365 isum = idx + ent.vd_aux; 6366 6367 for (j = 1; j < ent.vd_cnt; j++) 6368 { 6369 isum += aux.vda_next; 6370 vstart += aux.vda_next; 6371 6372 eaux = (Elf_External_Verdaux *) vstart; 6373 6374 aux.vda_name = BYTE_GET (eaux->vda_name); 6375 aux.vda_next = BYTE_GET (eaux->vda_next); 6376 6377 if (VALID_DYNAMIC_NAME (aux.vda_name)) 6378 printf (_(" %#06x: Parent %d: %s\n"), 6379 isum, j, GET_DYNAMIC_NAME (aux.vda_name)); 6380 else 6381 printf (_(" %#06x: Parent %d, name index: %ld\n"), 6382 isum, j, aux.vda_name); 6383 } 6384 6385 idx += ent.vd_next; 6386 } 6387 6388 free (edefs); 6389 } 6390 break; 6391 6392 case SHT_GNU_verneed: 6393 { 6394 Elf_External_Verneed *eneed; 6395 unsigned int idx; 6396 unsigned int cnt; 6397 6398 found = 1; 6399 6400 printf (_("\nVersion needs section '%s' contains %ld entries:\n"), 6401 SECTION_NAME (section), section->sh_info); 6402 6403 printf (_(" Addr: 0x")); 6404 printf_vma (section->sh_addr); 6405 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"), 6406 (unsigned long) section->sh_offset, section->sh_link, 6407 SECTION_HEADER_INDEX (section->sh_link) 6408 < elf_header.e_shnum 6409 ? SECTION_NAME (SECTION_HEADER (section->sh_link)) 6410 : "<corrupt>"); 6411 6412 eneed = get_data (NULL, file, section->sh_offset, 1, 6413 section->sh_size, 6414 _("version need section")); 6415 if (!eneed) 6416 break; 6417 6418 for (idx = cnt = 0; cnt < section->sh_info; ++cnt) 6419 { 6420 Elf_External_Verneed *entry; 6421 Elf_Internal_Verneed ent; 6422 int j; 6423 int isum; 6424 char *vstart; 6425 6426 vstart = ((char *) eneed) + idx; 6427 6428 entry = (Elf_External_Verneed *) vstart; 6429 6430 ent.vn_version = BYTE_GET (entry->vn_version); 6431 ent.vn_cnt = BYTE_GET (entry->vn_cnt); 6432 ent.vn_file = BYTE_GET (entry->vn_file); 6433 ent.vn_aux = BYTE_GET (entry->vn_aux); 6434 ent.vn_next = BYTE_GET (entry->vn_next); 6435 6436 printf (_(" %#06x: Version: %d"), idx, ent.vn_version); 6437 6438 if (VALID_DYNAMIC_NAME (ent.vn_file)) 6439 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file)); 6440 else 6441 printf (_(" File: %lx"), ent.vn_file); 6442 6443 printf (_(" Cnt: %d\n"), ent.vn_cnt); 6444 6445 vstart += ent.vn_aux; 6446 6447 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j) 6448 { 6449 Elf_External_Vernaux *eaux; 6450 Elf_Internal_Vernaux aux; 6451 6452 eaux = (Elf_External_Vernaux *) vstart; 6453 6454 aux.vna_hash = BYTE_GET (eaux->vna_hash); 6455 aux.vna_flags = BYTE_GET (eaux->vna_flags); 6456 aux.vna_other = BYTE_GET (eaux->vna_other); 6457 aux.vna_name = BYTE_GET (eaux->vna_name); 6458 aux.vna_next = BYTE_GET (eaux->vna_next); 6459 6460 if (VALID_DYNAMIC_NAME (aux.vna_name)) 6461 printf (_(" %#06x: Name: %s"), 6462 isum, GET_DYNAMIC_NAME (aux.vna_name)); 6463 else 6464 printf (_(" %#06x: Name index: %lx"), 6465 isum, aux.vna_name); 6466 6467 printf (_(" Flags: %s Version: %d\n"), 6468 get_ver_flags (aux.vna_flags), aux.vna_other); 6469 6470 isum += aux.vna_next; 6471 vstart += aux.vna_next; 6472 } 6473 6474 idx += ent.vn_next; 6475 } 6476 6477 free (eneed); 6478 } 6479 break; 6480 6481 case SHT_GNU_versym: 6482 { 6483 Elf_Internal_Shdr *link_section; 6484 int total; 6485 int cnt; 6486 unsigned char *edata; 6487 unsigned short *data; 6488 char *strtab; 6489 Elf_Internal_Sym *symbols; 6490 Elf_Internal_Shdr *string_sec; 6491 long off; 6492 6493 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum) 6494 break; 6495 6496 link_section = SECTION_HEADER (section->sh_link); 6497 total = section->sh_size / sizeof (Elf_External_Versym); 6498 6499 if (SECTION_HEADER_INDEX (link_section->sh_link) 6500 >= elf_header.e_shnum) 6501 break; 6502 6503 found = 1; 6504 6505 symbols = GET_ELF_SYMBOLS (file, link_section); 6506 6507 string_sec = SECTION_HEADER (link_section->sh_link); 6508 6509 strtab = get_data (NULL, file, string_sec->sh_offset, 1, 6510 string_sec->sh_size, _("version string table")); 6511 if (!strtab) 6512 break; 6513 6514 printf (_("\nVersion symbols section '%s' contains %d entries:\n"), 6515 SECTION_NAME (section), total); 6516 6517 printf (_(" Addr: ")); 6518 printf_vma (section->sh_addr); 6519 printf (_(" Offset: %#08lx Link: %lx (%s)\n"), 6520 (unsigned long) section->sh_offset, section->sh_link, 6521 SECTION_NAME (link_section)); 6522 6523 off = offset_from_vma (file, 6524 version_info[DT_VERSIONTAGIDX (DT_VERSYM)], 6525 total * sizeof (short)); 6526 edata = get_data (NULL, file, off, total, sizeof (short), 6527 _("version symbol data")); 6528 if (!edata) 6529 { 6530 free (strtab); 6531 break; 6532 } 6533 6534 data = cmalloc (total, sizeof (short)); 6535 6536 for (cnt = total; cnt --;) 6537 data[cnt] = byte_get (edata + cnt * sizeof (short), 6538 sizeof (short)); 6539 6540 free (edata); 6541 6542 for (cnt = 0; cnt < total; cnt += 4) 6543 { 6544 int j, nn; 6545 int check_def, check_need; 6546 char *name; 6547 6548 printf (" %03x:", cnt); 6549 6550 for (j = 0; (j < 4) && (cnt + j) < total; ++j) 6551 switch (data[cnt + j]) 6552 { 6553 case 0: 6554 fputs (_(" 0 (*local*) "), stdout); 6555 break; 6556 6557 case 1: 6558 fputs (_(" 1 (*global*) "), stdout); 6559 break; 6560 6561 default: 6562 nn = printf ("%4x%c", data[cnt + j] & 0x7fff, 6563 data[cnt + j] & 0x8000 ? 'h' : ' '); 6564 6565 check_def = 1; 6566 check_need = 1; 6567 if (SECTION_HEADER_INDEX (symbols[cnt + j].st_shndx) 6568 >= elf_header.e_shnum 6569 || SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type 6570 != SHT_NOBITS) 6571 { 6572 if (symbols[cnt + j].st_shndx == SHN_UNDEF) 6573 check_def = 0; 6574 else 6575 check_need = 0; 6576 } 6577 6578 if (check_need 6579 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)]) 6580 { 6581 Elf_Internal_Verneed ivn; 6582 unsigned long offset; 6583 6584 offset = offset_from_vma 6585 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)], 6586 sizeof (Elf_External_Verneed)); 6587 6588 do 6589 { 6590 Elf_Internal_Vernaux ivna; 6591 Elf_External_Verneed evn; 6592 Elf_External_Vernaux evna; 6593 unsigned long a_off; 6594 6595 get_data (&evn, file, offset, sizeof (evn), 1, 6596 _("version need")); 6597 6598 ivn.vn_aux = BYTE_GET (evn.vn_aux); 6599 ivn.vn_next = BYTE_GET (evn.vn_next); 6600 6601 a_off = offset + ivn.vn_aux; 6602 6603 do 6604 { 6605 get_data (&evna, file, a_off, sizeof (evna), 6606 1, _("version need aux (2)")); 6607 6608 ivna.vna_next = BYTE_GET (evna.vna_next); 6609 ivna.vna_other = BYTE_GET (evna.vna_other); 6610 6611 a_off += ivna.vna_next; 6612 } 6613 while (ivna.vna_other != data[cnt + j] 6614 && ivna.vna_next != 0); 6615 6616 if (ivna.vna_other == data[cnt + j]) 6617 { 6618 ivna.vna_name = BYTE_GET (evna.vna_name); 6619 6620 name = strtab + ivna.vna_name; 6621 nn += printf ("(%s%-*s", 6622 name, 6623 12 - (int) strlen (name), 6624 ")"); 6625 check_def = 0; 6626 break; 6627 } 6628 6629 offset += ivn.vn_next; 6630 } 6631 while (ivn.vn_next); 6632 } 6633 6634 if (check_def && data[cnt + j] != 0x8001 6635 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)]) 6636 { 6637 Elf_Internal_Verdef ivd; 6638 Elf_External_Verdef evd; 6639 unsigned long offset; 6640 6641 offset = offset_from_vma 6642 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)], 6643 sizeof evd); 6644 6645 do 6646 { 6647 get_data (&evd, file, offset, sizeof (evd), 1, 6648 _("version def")); 6649 6650 ivd.vd_next = BYTE_GET (evd.vd_next); 6651 ivd.vd_ndx = BYTE_GET (evd.vd_ndx); 6652 6653 offset += ivd.vd_next; 6654 } 6655 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff) 6656 && ivd.vd_next != 0); 6657 6658 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff)) 6659 { 6660 Elf_External_Verdaux evda; 6661 Elf_Internal_Verdaux ivda; 6662 6663 ivd.vd_aux = BYTE_GET (evd.vd_aux); 6664 6665 get_data (&evda, file, 6666 offset - ivd.vd_next + ivd.vd_aux, 6667 sizeof (evda), 1, 6668 _("version def aux")); 6669 6670 ivda.vda_name = BYTE_GET (evda.vda_name); 6671 6672 name = strtab + ivda.vda_name; 6673 nn += printf ("(%s%-*s", 6674 name, 6675 12 - (int) strlen (name), 6676 ")"); 6677 } 6678 } 6679 6680 if (nn < 18) 6681 printf ("%*c", 18 - nn, ' '); 6682 } 6683 6684 putchar ('\n'); 6685 } 6686 6687 free (data); 6688 free (strtab); 6689 free (symbols); 6690 } 6691 break; 6692 6693 default: 6694 break; 6695 } 6696 } 6697 6698 if (! found) 6699 printf (_("\nNo version information found in this file.\n")); 6700 6701 return 1; 6702 } 6703 6704 static const char * 6705 get_symbol_binding (unsigned int binding) 6706 { 6707 static char buff[32]; 6708 6709 switch (binding) 6710 { 6711 case STB_LOCAL: return "LOCAL"; 6712 case STB_GLOBAL: return "GLOBAL"; 6713 case STB_WEAK: return "WEAK"; 6714 default: 6715 if (binding >= STB_LOPROC && binding <= STB_HIPROC) 6716 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), 6717 binding); 6718 else if (binding >= STB_LOOS && binding <= STB_HIOS) 6719 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding); 6720 else 6721 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding); 6722 return buff; 6723 } 6724 } 6725 6726 static const char * 6727 get_symbol_type (unsigned int type) 6728 { 6729 static char buff[32]; 6730 6731 switch (type) 6732 { 6733 case STT_NOTYPE: return "NOTYPE"; 6734 case STT_OBJECT: return "OBJECT"; 6735 case STT_FUNC: return "FUNC"; 6736 case STT_SECTION: return "SECTION"; 6737 case STT_FILE: return "FILE"; 6738 case STT_COMMON: return "COMMON"; 6739 case STT_TLS: return "TLS"; 6740 default: 6741 if (type >= STT_LOPROC && type <= STT_HIPROC) 6742 { 6743 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC) 6744 return "THUMB_FUNC"; 6745 6746 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER) 6747 return "REGISTER"; 6748 6749 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI) 6750 return "PARISC_MILLI"; 6751 6752 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type); 6753 } 6754 else if (type >= STT_LOOS && type <= STT_HIOS) 6755 { 6756 if (elf_header.e_machine == EM_PARISC) 6757 { 6758 if (type == STT_HP_OPAQUE) 6759 return "HP_OPAQUE"; 6760 if (type == STT_HP_STUB) 6761 return "HP_STUB"; 6762 } 6763 6764 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type); 6765 } 6766 else 6767 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type); 6768 return buff; 6769 } 6770 } 6771 6772 static const char * 6773 get_symbol_visibility (unsigned int visibility) 6774 { 6775 switch (visibility) 6776 { 6777 case STV_DEFAULT: return "DEFAULT"; 6778 case STV_INTERNAL: return "INTERNAL"; 6779 case STV_HIDDEN: return "HIDDEN"; 6780 case STV_PROTECTED: return "PROTECTED"; 6781 default: abort (); 6782 } 6783 } 6784 6785 static const char * 6786 get_mips_symbol_other (unsigned int other) 6787 { 6788 switch (other) 6789 { 6790 case STO_OPTIONAL: return "OPTIONAL"; 6791 case STO_MIPS16: return "MIPS16"; 6792 default: return NULL; 6793 } 6794 } 6795 6796 static const char * 6797 get_symbol_other (unsigned int other) 6798 { 6799 const char * result = NULL; 6800 static char buff [32]; 6801 6802 if (other == 0) 6803 return ""; 6804 6805 switch (elf_header.e_machine) 6806 { 6807 case EM_MIPS: 6808 result = get_mips_symbol_other (other); 6809 default: 6810 break; 6811 } 6812 6813 if (result) 6814 return result; 6815 6816 snprintf (buff, sizeof buff, _("<other>: %x"), other); 6817 return buff; 6818 } 6819 6820 static const char * 6821 get_symbol_index_type (unsigned int type) 6822 { 6823 static char buff[32]; 6824 6825 switch (type) 6826 { 6827 case SHN_UNDEF: return "UND"; 6828 case SHN_ABS: return "ABS"; 6829 case SHN_COMMON: return "COM"; 6830 default: 6831 if (type == SHN_IA_64_ANSI_COMMON 6832 && elf_header.e_machine == EM_IA_64 6833 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX) 6834 return "ANSI_COM"; 6835 else if (elf_header.e_machine == EM_X86_64 6836 && type == SHN_X86_64_LCOMMON) 6837 return "LARGE_COM"; 6838 else if (type >= SHN_LOPROC && type <= SHN_HIPROC) 6839 sprintf (buff, "PRC[0x%04x]", type); 6840 else if (type >= SHN_LOOS && type <= SHN_HIOS) 6841 sprintf (buff, "OS [0x%04x]", type); 6842 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE) 6843 sprintf (buff, "RSV[0x%04x]", type); 6844 else 6845 sprintf (buff, "%3d", type); 6846 break; 6847 } 6848 6849 return buff; 6850 } 6851 6852 static bfd_vma * 6853 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size) 6854 { 6855 unsigned char *e_data; 6856 bfd_vma *i_data; 6857 6858 e_data = cmalloc (number, ent_size); 6859 6860 if (e_data == NULL) 6861 { 6862 error (_("Out of memory\n")); 6863 return NULL; 6864 } 6865 6866 if (fread (e_data, ent_size, number, file) != number) 6867 { 6868 error (_("Unable to read in dynamic data\n")); 6869 return NULL; 6870 } 6871 6872 i_data = cmalloc (number, sizeof (*i_data)); 6873 6874 if (i_data == NULL) 6875 { 6876 error (_("Out of memory\n")); 6877 free (e_data); 6878 return NULL; 6879 } 6880 6881 while (number--) 6882 i_data[number] = byte_get (e_data + number * ent_size, ent_size); 6883 6884 free (e_data); 6885 6886 return i_data; 6887 } 6888 6889 /* Dump the symbol table. */ 6890 static int 6891 process_symbol_table (FILE *file) 6892 { 6893 Elf_Internal_Shdr *section; 6894 bfd_vma nbuckets = 0; 6895 bfd_vma nchains = 0; 6896 bfd_vma *buckets = NULL; 6897 bfd_vma *chains = NULL; 6898 6899 if (! do_syms && !do_histogram) 6900 return 1; 6901 6902 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL) 6903 || do_histogram)) 6904 { 6905 unsigned char nb[8]; 6906 unsigned char nc[8]; 6907 int hash_ent_size = 4; 6908 6909 if ((elf_header.e_machine == EM_ALPHA 6910 || elf_header.e_machine == EM_S390 6911 || elf_header.e_machine == EM_S390_OLD) 6912 && elf_header.e_ident[EI_CLASS] == ELFCLASS64) 6913 hash_ent_size = 8; 6914 6915 if (fseek (file, 6916 (archive_file_offset 6917 + offset_from_vma (file, dynamic_info[DT_HASH], 6918 sizeof nb + sizeof nc)), 6919 SEEK_SET)) 6920 { 6921 error (_("Unable to seek to start of dynamic information")); 6922 return 0; 6923 } 6924 6925 if (fread (nb, hash_ent_size, 1, file) != 1) 6926 { 6927 error (_("Failed to read in number of buckets\n")); 6928 return 0; 6929 } 6930 6931 if (fread (nc, hash_ent_size, 1, file) != 1) 6932 { 6933 error (_("Failed to read in number of chains\n")); 6934 return 0; 6935 } 6936 6937 nbuckets = byte_get (nb, hash_ent_size); 6938 nchains = byte_get (nc, hash_ent_size); 6939 6940 buckets = get_dynamic_data (file, nbuckets, hash_ent_size); 6941 chains = get_dynamic_data (file, nchains, hash_ent_size); 6942 6943 if (buckets == NULL || chains == NULL) 6944 return 0; 6945 } 6946 6947 if (do_syms 6948 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL) 6949 { 6950 unsigned long hn; 6951 bfd_vma si; 6952 6953 printf (_("\nSymbol table for image:\n")); 6954 if (is_32bit_elf) 6955 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n")); 6956 else 6957 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n")); 6958 6959 for (hn = 0; hn < nbuckets; hn++) 6960 { 6961 if (! buckets[hn]) 6962 continue; 6963 6964 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si]) 6965 { 6966 Elf_Internal_Sym *psym; 6967 int n; 6968 6969 psym = dynamic_symbols + si; 6970 6971 n = print_vma (si, DEC_5); 6972 if (n < 5) 6973 fputs (" " + n, stdout); 6974 printf (" %3lu: ", hn); 6975 print_vma (psym->st_value, LONG_HEX); 6976 putchar (' '); 6977 print_vma (psym->st_size, DEC_5); 6978 6979 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info))); 6980 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info))); 6981 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other))); 6982 /* Check to see if any other bits in the st_other field are set. 6983 Note - displaying this information disrupts the layout of the 6984 table being generated, but for the moment this case is very rare. */ 6985 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)) 6986 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))); 6987 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx)); 6988 if (VALID_DYNAMIC_NAME (psym->st_name)) 6989 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name)); 6990 else 6991 printf (" <corrupt: %14ld>", psym->st_name); 6992 putchar ('\n'); 6993 } 6994 } 6995 } 6996 else if (do_syms && !do_using_dynamic) 6997 { 6998 unsigned int i; 6999 7000 for (i = 0, section = section_headers; 7001 i < elf_header.e_shnum; 7002 i++, section++) 7003 { 7004 unsigned int si; 7005 char *strtab = NULL; 7006 unsigned long int strtab_size = 0; 7007 Elf_Internal_Sym *symtab; 7008 Elf_Internal_Sym *psym; 7009 7010 7011 if ( section->sh_type != SHT_SYMTAB 7012 && section->sh_type != SHT_DYNSYM) 7013 continue; 7014 7015 printf (_("\nSymbol table '%s' contains %lu entries:\n"), 7016 SECTION_NAME (section), 7017 (unsigned long) (section->sh_size / section->sh_entsize)); 7018 if (is_32bit_elf) 7019 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n")); 7020 else 7021 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n")); 7022 7023 symtab = GET_ELF_SYMBOLS (file, section); 7024 if (symtab == NULL) 7025 continue; 7026 7027 if (section->sh_link == elf_header.e_shstrndx) 7028 { 7029 strtab = string_table; 7030 strtab_size = string_table_length; 7031 } 7032 else if (SECTION_HEADER_INDEX (section->sh_link) < elf_header.e_shnum) 7033 { 7034 Elf_Internal_Shdr *string_sec; 7035 7036 string_sec = SECTION_HEADER (section->sh_link); 7037 7038 strtab = get_data (NULL, file, string_sec->sh_offset, 7039 1, string_sec->sh_size, _("string table")); 7040 strtab_size = strtab != NULL ? string_sec->sh_size : 0; 7041 } 7042 7043 for (si = 0, psym = symtab; 7044 si < section->sh_size / section->sh_entsize; 7045 si++, psym++) 7046 { 7047 printf ("%6d: ", si); 7048 print_vma (psym->st_value, LONG_HEX); 7049 putchar (' '); 7050 print_vma (psym->st_size, DEC_5); 7051 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info))); 7052 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info))); 7053 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other))); 7054 /* Check to see if any other bits in the st_other field are set. 7055 Note - displaying this information disrupts the layout of the 7056 table being generated, but for the moment this case is very rare. */ 7057 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)) 7058 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))); 7059 printf (" %4s ", get_symbol_index_type (psym->st_shndx)); 7060 print_symbol (25, psym->st_name < strtab_size 7061 ? strtab + psym->st_name : "<corrupt>"); 7062 7063 if (section->sh_type == SHT_DYNSYM && 7064 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0) 7065 { 7066 unsigned char data[2]; 7067 unsigned short vers_data; 7068 unsigned long offset; 7069 int is_nobits; 7070 int check_def; 7071 7072 offset = offset_from_vma 7073 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)], 7074 sizeof data + si * sizeof (vers_data)); 7075 7076 get_data (&data, file, offset + si * sizeof (vers_data), 7077 sizeof (data), 1, _("version data")); 7078 7079 vers_data = byte_get (data, 2); 7080 7081 is_nobits = (SECTION_HEADER_INDEX (psym->st_shndx) 7082 < elf_header.e_shnum 7083 && SECTION_HEADER (psym->st_shndx)->sh_type 7084 == SHT_NOBITS); 7085 7086 check_def = (psym->st_shndx != SHN_UNDEF); 7087 7088 if ((vers_data & 0x8000) || vers_data > 1) 7089 { 7090 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)] 7091 && (is_nobits || ! check_def)) 7092 { 7093 Elf_External_Verneed evn; 7094 Elf_Internal_Verneed ivn; 7095 Elf_Internal_Vernaux ivna; 7096 7097 /* We must test both. */ 7098 offset = offset_from_vma 7099 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)], 7100 sizeof evn); 7101 7102 do 7103 { 7104 unsigned long vna_off; 7105 7106 get_data (&evn, file, offset, sizeof (evn), 1, 7107 _("version need")); 7108 7109 ivn.vn_aux = BYTE_GET (evn.vn_aux); 7110 ivn.vn_next = BYTE_GET (evn.vn_next); 7111 7112 vna_off = offset + ivn.vn_aux; 7113 7114 do 7115 { 7116 Elf_External_Vernaux evna; 7117 7118 get_data (&evna, file, vna_off, 7119 sizeof (evna), 1, 7120 _("version need aux (3)")); 7121 7122 ivna.vna_other = BYTE_GET (evna.vna_other); 7123 ivna.vna_next = BYTE_GET (evna.vna_next); 7124 ivna.vna_name = BYTE_GET (evna.vna_name); 7125 7126 vna_off += ivna.vna_next; 7127 } 7128 while (ivna.vna_other != vers_data 7129 && ivna.vna_next != 0); 7130 7131 if (ivna.vna_other == vers_data) 7132 break; 7133 7134 offset += ivn.vn_next; 7135 } 7136 while (ivn.vn_next != 0); 7137 7138 if (ivna.vna_other == vers_data) 7139 { 7140 printf ("@%s (%d)", 7141 ivna.vna_name < strtab_size 7142 ? strtab + ivna.vna_name : "<corrupt>", 7143 ivna.vna_other); 7144 check_def = 0; 7145 } 7146 else if (! is_nobits) 7147 error (_("bad dynamic symbol")); 7148 else 7149 check_def = 1; 7150 } 7151 7152 if (check_def) 7153 { 7154 if (vers_data != 0x8001 7155 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)]) 7156 { 7157 Elf_Internal_Verdef ivd; 7158 Elf_Internal_Verdaux ivda; 7159 Elf_External_Verdaux evda; 7160 unsigned long offset; 7161 7162 offset = offset_from_vma 7163 (file, 7164 version_info[DT_VERSIONTAGIDX (DT_VERDEF)], 7165 sizeof (Elf_External_Verdef)); 7166 7167 do 7168 { 7169 Elf_External_Verdef evd; 7170 7171 get_data (&evd, file, offset, sizeof (evd), 7172 1, _("version def")); 7173 7174 ivd.vd_ndx = BYTE_GET (evd.vd_ndx); 7175 ivd.vd_aux = BYTE_GET (evd.vd_aux); 7176 ivd.vd_next = BYTE_GET (evd.vd_next); 7177 7178 offset += ivd.vd_next; 7179 } 7180 while (ivd.vd_ndx != (vers_data & 0x7fff) 7181 && ivd.vd_next != 0); 7182 7183 offset -= ivd.vd_next; 7184 offset += ivd.vd_aux; 7185 7186 get_data (&evda, file, offset, sizeof (evda), 7187 1, _("version def aux")); 7188 7189 ivda.vda_name = BYTE_GET (evda.vda_name); 7190 7191 if (psym->st_name != ivda.vda_name) 7192 printf ((vers_data & 0x8000) 7193 ? "@%s" : "@@%s", 7194 ivda.vda_name < strtab_size 7195 ? strtab + ivda.vda_name : "<corrupt>"); 7196 } 7197 } 7198 } 7199 } 7200 7201 putchar ('\n'); 7202 } 7203 7204 free (symtab); 7205 if (strtab != string_table) 7206 free (strtab); 7207 } 7208 } 7209 else if (do_syms) 7210 printf 7211 (_("\nDynamic symbol information is not available for displaying symbols.\n")); 7212 7213 if (do_histogram && buckets != NULL) 7214 { 7215 unsigned long *lengths; 7216 unsigned long *counts; 7217 unsigned long hn; 7218 bfd_vma si; 7219 unsigned long maxlength = 0; 7220 unsigned long nzero_counts = 0; 7221 unsigned long nsyms = 0; 7222 7223 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"), 7224 (unsigned long) nbuckets); 7225 printf (_(" Length Number %% of total Coverage\n")); 7226 7227 lengths = calloc (nbuckets, sizeof (*lengths)); 7228 if (lengths == NULL) 7229 { 7230 error (_("Out of memory")); 7231 return 0; 7232 } 7233 for (hn = 0; hn < nbuckets; ++hn) 7234 { 7235 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si]) 7236 { 7237 ++nsyms; 7238 if (maxlength < ++lengths[hn]) 7239 ++maxlength; 7240 } 7241 } 7242 7243 counts = calloc (maxlength + 1, sizeof (*counts)); 7244 if (counts == NULL) 7245 { 7246 error (_("Out of memory")); 7247 return 0; 7248 } 7249 7250 for (hn = 0; hn < nbuckets; ++hn) 7251 ++counts[lengths[hn]]; 7252 7253 if (nbuckets > 0) 7254 { 7255 unsigned long i; 7256 printf (" 0 %-10lu (%5.1f%%)\n", 7257 counts[0], (counts[0] * 100.0) / nbuckets); 7258 for (i = 1; i <= maxlength; ++i) 7259 { 7260 nzero_counts += counts[i] * i; 7261 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n", 7262 i, counts[i], (counts[i] * 100.0) / nbuckets, 7263 (nzero_counts * 100.0) / nsyms); 7264 } 7265 } 7266 7267 free (counts); 7268 free (lengths); 7269 } 7270 7271 if (buckets != NULL) 7272 { 7273 free (buckets); 7274 free (chains); 7275 } 7276 7277 return 1; 7278 } 7279 7280 static int 7281 process_syminfo (FILE *file ATTRIBUTE_UNUSED) 7282 { 7283 unsigned int i; 7284 7285 if (dynamic_syminfo == NULL 7286 || !do_dynamic) 7287 /* No syminfo, this is ok. */ 7288 return 1; 7289 7290 /* There better should be a dynamic symbol section. */ 7291 if (dynamic_symbols == NULL || dynamic_strings == NULL) 7292 return 0; 7293 7294 if (dynamic_addr) 7295 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"), 7296 dynamic_syminfo_offset, dynamic_syminfo_nent); 7297 7298 printf (_(" Num: Name BoundTo Flags\n")); 7299 for (i = 0; i < dynamic_syminfo_nent; ++i) 7300 { 7301 unsigned short int flags = dynamic_syminfo[i].si_flags; 7302 7303 printf ("%4d: ", i); 7304 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name)) 7305 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name)); 7306 else 7307 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name); 7308 putchar (' '); 7309 7310 switch (dynamic_syminfo[i].si_boundto) 7311 { 7312 case SYMINFO_BT_SELF: 7313 fputs ("SELF ", stdout); 7314 break; 7315 case SYMINFO_BT_PARENT: 7316 fputs ("PARENT ", stdout); 7317 break; 7318 default: 7319 if (dynamic_syminfo[i].si_boundto > 0 7320 && dynamic_syminfo[i].si_boundto < dynamic_nent 7321 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val)) 7322 { 7323 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val)); 7324 putchar (' ' ); 7325 } 7326 else 7327 printf ("%-10d ", dynamic_syminfo[i].si_boundto); 7328 break; 7329 } 7330 7331 if (flags & SYMINFO_FLG_DIRECT) 7332 printf (" DIRECT"); 7333 if (flags & SYMINFO_FLG_PASSTHRU) 7334 printf (" PASSTHRU"); 7335 if (flags & SYMINFO_FLG_COPY) 7336 printf (" COPY"); 7337 if (flags & SYMINFO_FLG_LAZYLOAD) 7338 printf (" LAZYLOAD"); 7339 7340 puts (""); 7341 } 7342 7343 return 1; 7344 } 7345 7346 #ifdef SUPPORT_DISASSEMBLY 7347 static int 7348 disassemble_section (Elf_Internal_Shdr *section, FILE *file) 7349 { 7350 printf (_("\nAssembly dump of section %s\n"), 7351 SECTION_NAME (section)); 7352 7353 /* XXX -- to be done --- XXX */ 7354 7355 return 1; 7356 } 7357 #endif 7358 7359 static int 7360 dump_section (Elf_Internal_Shdr *section, FILE *file) 7361 { 7362 bfd_size_type bytes; 7363 bfd_vma addr; 7364 unsigned char *data; 7365 unsigned char *start; 7366 7367 bytes = section->sh_size; 7368 7369 if (bytes == 0 || section->sh_type == SHT_NOBITS) 7370 { 7371 printf (_("\nSection '%s' has no data to dump.\n"), 7372 SECTION_NAME (section)); 7373 return 0; 7374 } 7375 else 7376 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section)); 7377 7378 addr = section->sh_addr; 7379 7380 start = get_data (NULL, file, section->sh_offset, 1, bytes, 7381 _("section data")); 7382 if (!start) 7383 return 0; 7384 7385 data = start; 7386 7387 while (bytes) 7388 { 7389 int j; 7390 int k; 7391 int lbytes; 7392 7393 lbytes = (bytes > 16 ? 16 : bytes); 7394 7395 printf (" 0x%8.8lx ", (unsigned long) addr); 7396 7397 switch (elf_header.e_ident[EI_DATA]) 7398 { 7399 default: 7400 case ELFDATA2LSB: 7401 for (j = 15; j >= 0; j --) 7402 { 7403 if (j < lbytes) 7404 printf ("%2.2x", data[j]); 7405 else 7406 printf (" "); 7407 7408 if (!(j & 0x3)) 7409 printf (" "); 7410 } 7411 break; 7412 7413 case ELFDATA2MSB: 7414 for (j = 0; j < 16; j++) 7415 { 7416 if (j < lbytes) 7417 printf ("%2.2x", data[j]); 7418 else 7419 printf (" "); 7420 7421 if ((j & 3) == 3) 7422 printf (" "); 7423 } 7424 break; 7425 } 7426 7427 for (j = 0; j < lbytes; j++) 7428 { 7429 k = data[j]; 7430 if (k >= ' ' && k < 0x7f) 7431 printf ("%c", k); 7432 else 7433 printf ("."); 7434 } 7435 7436 putchar ('\n'); 7437 7438 data += lbytes; 7439 addr += lbytes; 7440 bytes -= lbytes; 7441 } 7442 7443 free (start); 7444 7445 return 1; 7446 } 7447 7448 /* Apply addends of RELA relocations. */ 7449 7450 static int 7451 debug_apply_rela_addends (void *file, 7452 Elf_Internal_Shdr *section, 7453 unsigned char *start) 7454 { 7455 Elf_Internal_Shdr *relsec; 7456 unsigned char *end = start + section->sh_size; 7457 /* FIXME: The relocation field size is relocation type dependent. */ 7458 unsigned int reloc_size = 4; 7459 7460 if (!is_relocatable) 7461 return 1; 7462 7463 if (section->sh_size < reloc_size) 7464 return 1; 7465 7466 for (relsec = section_headers; 7467 relsec < section_headers + elf_header.e_shnum; 7468 ++relsec) 7469 { 7470 unsigned long nrelas; 7471 Elf_Internal_Rela *rela, *rp; 7472 Elf_Internal_Shdr *symsec; 7473 Elf_Internal_Sym *symtab; 7474 Elf_Internal_Sym *sym; 7475 7476 if (relsec->sh_type != SHT_RELA 7477 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum 7478 || SECTION_HEADER (relsec->sh_info) != section 7479 || relsec->sh_size == 0 7480 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum) 7481 continue; 7482 7483 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size, 7484 &rela, &nrelas)) 7485 return 0; 7486 7487 symsec = SECTION_HEADER (relsec->sh_link); 7488 symtab = GET_ELF_SYMBOLS (file, symsec); 7489 7490 for (rp = rela; rp < rela + nrelas; ++rp) 7491 { 7492 unsigned char *loc; 7493 7494 loc = start + rp->r_offset; 7495 if ((loc + reloc_size) > end) 7496 { 7497 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"), 7498 (unsigned long) rp->r_offset, 7499 SECTION_NAME (section)); 7500 continue; 7501 } 7502 7503 if (is_32bit_elf) 7504 { 7505 sym = symtab + ELF32_R_SYM (rp->r_info); 7506 7507 if (ELF32_R_SYM (rp->r_info) != 0 7508 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION 7509 /* Relocations against object symbols can happen, 7510 eg when referencing a global array. For an 7511 example of this see the _clz.o binary in libgcc.a. */ 7512 && ELF32_ST_TYPE (sym->st_info) != STT_OBJECT) 7513 { 7514 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"), 7515 get_symbol_type (ELF32_ST_TYPE (sym->st_info)), 7516 SECTION_NAME (section)); 7517 continue; 7518 } 7519 } 7520 else 7521 { 7522 /* In MIPS little-endian objects, r_info isn't really a 7523 64-bit little-endian value: it has a 32-bit little-endian 7524 symbol index followed by four individual byte fields. 7525 Reorder INFO accordingly. */ 7526 if (elf_header.e_machine == EM_MIPS 7527 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB) 7528 rp->r_info = (((rp->r_info & 0xffffffff) << 32) 7529 | ((rp->r_info >> 56) & 0xff) 7530 | ((rp->r_info >> 40) & 0xff00) 7531 | ((rp->r_info >> 24) & 0xff0000) 7532 | ((rp->r_info >> 8) & 0xff000000)); 7533 7534 sym = symtab + ELF64_R_SYM (rp->r_info); 7535 7536 if (ELF64_R_SYM (rp->r_info) != 0 7537 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION 7538 && ELF64_ST_TYPE (sym->st_info) != STT_OBJECT) 7539 { 7540 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"), 7541 get_symbol_type (ELF64_ST_TYPE (sym->st_info)), 7542 SECTION_NAME (section)); 7543 continue; 7544 } 7545 } 7546 7547 byte_put (loc, rp->r_addend, reloc_size); 7548 } 7549 7550 free (symtab); 7551 free (rela); 7552 break; 7553 } 7554 return 1; 7555 } 7556 7557 int 7558 load_debug_section (enum dwarf_section_display_enum debug, void *file) 7559 { 7560 struct dwarf_section *section = &debug_displays [debug].section; 7561 Elf_Internal_Shdr *sec; 7562 char buf [64]; 7563 7564 /* If it is already loaded, do nothing. */ 7565 if (section->start != NULL) 7566 return 1; 7567 7568 /* Locate the debug section. */ 7569 sec = find_section (section->name); 7570 if (sec == NULL) 7571 return 0; 7572 7573 snprintf (buf, sizeof (buf), _("%s section data"), section->name); 7574 section->address = sec->sh_addr; 7575 section->size = sec->sh_size; 7576 section->start = get_data (NULL, file, sec->sh_offset, 1, 7577 sec->sh_size, buf); 7578 7579 if (debug_displays [debug].relocate) 7580 debug_apply_rela_addends (file, sec, section->start); 7581 7582 return section->start != NULL; 7583 } 7584 7585 void 7586 free_debug_section (enum dwarf_section_display_enum debug) 7587 { 7588 struct dwarf_section *section = &debug_displays [debug].section; 7589 7590 if (section->start == NULL) 7591 return; 7592 7593 free ((char *) section->start); 7594 section->start = NULL; 7595 section->address = 0; 7596 section->size = 0; 7597 } 7598 7599 static int 7600 display_debug_section (Elf_Internal_Shdr *section, FILE *file) 7601 { 7602 char *name = SECTION_NAME (section); 7603 bfd_size_type length; 7604 int result = 1; 7605 enum dwarf_section_display_enum i; 7606 7607 length = section->sh_size; 7608 if (length == 0) 7609 { 7610 printf (_("\nSection '%s' has no debugging data.\n"), name); 7611 return 0; 7612 } 7613 7614 if (strneq (name, ".gnu.linkonce.wi.", 17)) 7615 name = ".debug_info"; 7616 7617 /* See if we know how to display the contents of this section. */ 7618 for (i = 0; i < max; i++) 7619 if (streq (debug_displays[i].section.name, name)) 7620 { 7621 struct dwarf_section *sec = &debug_displays [i].section; 7622 7623 if (load_debug_section (i, file)) 7624 { 7625 result &= debug_displays[i].display (sec, file); 7626 7627 if (i != info && i != abbrev) 7628 free_debug_section (i); 7629 } 7630 7631 break; 7632 } 7633 7634 if (i == max) 7635 { 7636 printf (_("Unrecognized debug section: %s\n"), name); 7637 result = 0; 7638 } 7639 7640 return result; 7641 } 7642 7643 /* Set DUMP_SECTS for all sections where dumps were requested 7644 based on section name. */ 7645 7646 static void 7647 initialise_dumps_byname (void) 7648 { 7649 struct dump_list_entry *cur; 7650 7651 for (cur = dump_sects_byname; cur; cur = cur->next) 7652 { 7653 unsigned int i; 7654 int any; 7655 7656 for (i = 0, any = 0; i < elf_header.e_shnum; i++) 7657 if (streq (SECTION_NAME (section_headers + i), cur->name)) 7658 { 7659 request_dump (i, cur->type); 7660 any = 1; 7661 } 7662 7663 if (!any) 7664 warn (_("Section '%s' was not dumped because it does not exist!\n"), 7665 cur->name); 7666 } 7667 } 7668 7669 static void 7670 process_section_contents (FILE *file) 7671 { 7672 Elf_Internal_Shdr *section; 7673 unsigned int i; 7674 7675 if (! do_dump) 7676 return; 7677 7678 initialise_dumps_byname (); 7679 7680 for (i = 0, section = section_headers; 7681 i < elf_header.e_shnum && i < num_dump_sects; 7682 i++, section++) 7683 { 7684 #ifdef SUPPORT_DISASSEMBLY 7685 if (dump_sects[i] & DISASS_DUMP) 7686 disassemble_section (section, file); 7687 #endif 7688 if (dump_sects[i] & HEX_DUMP) 7689 dump_section (section, file); 7690 7691 if (dump_sects[i] & DEBUG_DUMP) 7692 display_debug_section (section, file); 7693 } 7694 7695 /* Check to see if the user requested a 7696 dump of a section that does not exist. */ 7697 while (i++ < num_dump_sects) 7698 if (dump_sects[i]) 7699 warn (_("Section %d was not dumped because it does not exist!\n"), i); 7700 } 7701 7702 static void 7703 process_mips_fpe_exception (int mask) 7704 { 7705 if (mask) 7706 { 7707 int first = 1; 7708 if (mask & OEX_FPU_INEX) 7709 fputs ("INEX", stdout), first = 0; 7710 if (mask & OEX_FPU_UFLO) 7711 printf ("%sUFLO", first ? "" : "|"), first = 0; 7712 if (mask & OEX_FPU_OFLO) 7713 printf ("%sOFLO", first ? "" : "|"), first = 0; 7714 if (mask & OEX_FPU_DIV0) 7715 printf ("%sDIV0", first ? "" : "|"), first = 0; 7716 if (mask & OEX_FPU_INVAL) 7717 printf ("%sINVAL", first ? "" : "|"); 7718 } 7719 else 7720 fputs ("0", stdout); 7721 } 7722 7723 /* ARM EABI attributes section. */ 7724 typedef struct 7725 { 7726 int tag; 7727 const char *name; 7728 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */ 7729 int type; 7730 const char **table; 7731 } arm_attr_public_tag; 7732 7733 static const char *arm_attr_tag_CPU_arch[] = 7734 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2", 7735 "v6K", "v7"}; 7736 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"}; 7737 static const char *arm_attr_tag_THUMB_ISA_use[] = 7738 {"No", "Thumb-1", "Thumb-2"}; 7739 static const char *arm_attr_tag_VFP_arch[] = {"No", "VFPv1", "VFPv2"}; 7740 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"}; 7741 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"}; 7742 static const char *arm_attr_tag_ABI_PCS_config[] = 7743 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004", 7744 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"}; 7745 static const char *arm_attr_tag_ABI_PCS_R9_use[] = 7746 {"V6", "SB", "TLS", "Unused"}; 7747 static const char *arm_attr_tag_ABI_PCS_RW_data[] = 7748 {"Absolute", "PC-relative", "SB-relative", "None"}; 7749 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] = 7750 {"Absolute", "PC-relative", "None"}; 7751 static const char *arm_attr_tag_ABI_PCS_GOT_use[] = 7752 {"None", "direct", "GOT-indirect"}; 7753 static const char *arm_attr_tag_ABI_PCS_wchar_t[] = 7754 {"None", "??? 1", "2", "??? 3", "4"}; 7755 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"}; 7756 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"}; 7757 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"}; 7758 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"}; 7759 static const char *arm_attr_tag_ABI_FP_number_model[] = 7760 {"Unused", "Finite", "RTABI", "IEEE 754"}; 7761 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"}; 7762 static const char *arm_attr_tag_ABI_align8_preserved[] = 7763 {"No", "Yes, except leaf SP", "Yes"}; 7764 static const char *arm_attr_tag_ABI_enum_size[] = 7765 {"Unused", "small", "int", "forced to int"}; 7766 static const char *arm_attr_tag_ABI_HardFP_use[] = 7767 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"}; 7768 static const char *arm_attr_tag_ABI_VFP_args[] = 7769 {"AAPCS", "VFP registers", "custom"}; 7770 static const char *arm_attr_tag_ABI_WMMX_args[] = 7771 {"AAPCS", "WMMX registers", "custom"}; 7772 static const char *arm_attr_tag_ABI_optimization_goals[] = 7773 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size", 7774 "Aggressive Size", "Prefer Debug", "Aggressive Debug"}; 7775 static const char *arm_attr_tag_ABI_FP_optimization_goals[] = 7776 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size", 7777 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"}; 7778 7779 #define LOOKUP(id, name) \ 7780 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name} 7781 static arm_attr_public_tag arm_attr_public_tags[] = 7782 { 7783 {4, "CPU_raw_name", 1, NULL}, 7784 {5, "CPU_name", 1, NULL}, 7785 LOOKUP(6, CPU_arch), 7786 {7, "CPU_arch_profile", 0, NULL}, 7787 LOOKUP(8, ARM_ISA_use), 7788 LOOKUP(9, THUMB_ISA_use), 7789 LOOKUP(10, VFP_arch), 7790 LOOKUP(11, WMMX_arch), 7791 LOOKUP(12, NEON_arch), 7792 LOOKUP(13, ABI_PCS_config), 7793 LOOKUP(14, ABI_PCS_R9_use), 7794 LOOKUP(15, ABI_PCS_RW_data), 7795 LOOKUP(16, ABI_PCS_RO_DATA), 7796 LOOKUP(17, ABI_PCS_GOT_use), 7797 LOOKUP(18, ABI_PCS_wchar_t), 7798 LOOKUP(19, ABI_FP_rounding), 7799 LOOKUP(20, ABI_FP_denormal), 7800 LOOKUP(21, ABI_FP_exceptions), 7801 LOOKUP(22, ABI_FP_user_exceptions), 7802 LOOKUP(23, ABI_FP_number_model), 7803 LOOKUP(24, ABI_align8_needed), 7804 LOOKUP(25, ABI_align8_preserved), 7805 LOOKUP(26, ABI_enum_size), 7806 LOOKUP(27, ABI_HardFP_use), 7807 LOOKUP(28, ABI_VFP_args), 7808 LOOKUP(29, ABI_WMMX_args), 7809 LOOKUP(30, ABI_optimization_goals), 7810 LOOKUP(31, ABI_FP_optimization_goals), 7811 {32, "compatibility", 0, NULL} 7812 }; 7813 #undef LOOKUP 7814 7815 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of 7816 bytes read. */ 7817 static unsigned int 7818 read_uleb128 (unsigned char *p, unsigned int *plen) 7819 { 7820 unsigned char c; 7821 unsigned int val; 7822 int shift; 7823 int len; 7824 7825 val = 0; 7826 shift = 0; 7827 len = 0; 7828 do 7829 { 7830 c = *(p++); 7831 len++; 7832 val |= ((unsigned int)c & 0x7f) << shift; 7833 shift += 7; 7834 } 7835 while (c & 0x80); 7836 7837 *plen = len; 7838 return val; 7839 } 7840 7841 static unsigned char * 7842 display_arm_attribute (unsigned char *p) 7843 { 7844 int tag; 7845 unsigned int len; 7846 int val; 7847 arm_attr_public_tag *attr; 7848 unsigned i; 7849 int type; 7850 7851 tag = read_uleb128 (p, &len); 7852 p += len; 7853 attr = NULL; 7854 for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++) 7855 { 7856 if (arm_attr_public_tags[i].tag == tag) 7857 { 7858 attr = &arm_attr_public_tags[i]; 7859 break; 7860 } 7861 } 7862 7863 if (attr) 7864 { 7865 printf (" Tag_%s: ", attr->name); 7866 switch (attr->type) 7867 { 7868 case 0: 7869 switch (tag) 7870 { 7871 case 7: /* Tag_CPU_arch_profile. */ 7872 val = read_uleb128 (p, &len); 7873 p += len; 7874 switch (val) 7875 { 7876 case 0: printf ("None\n"); break; 7877 case 'A': printf ("Application\n"); break; 7878 case 'R': printf ("Realtime\n"); break; 7879 case 'M': printf ("Microcontroller\n"); break; 7880 default: printf ("??? (%d)\n", val); break; 7881 } 7882 break; 7883 7884 case 32: /* Tag_compatibility. */ 7885 val = read_uleb128 (p, &len); 7886 p += len; 7887 printf ("flag = %d, vendor = %s\n", val, p); 7888 p += strlen((char *)p) + 1; 7889 break; 7890 7891 default: 7892 abort(); 7893 } 7894 return p; 7895 7896 case 1: 7897 case 2: 7898 type = attr->type; 7899 break; 7900 7901 default: 7902 assert (attr->type & 0x80); 7903 val = read_uleb128 (p, &len); 7904 p += len; 7905 type = attr->type & 0x7f; 7906 if (val >= type) 7907 printf ("??? (%d)\n", val); 7908 else 7909 printf ("%s\n", attr->table[val]); 7910 return p; 7911 } 7912 } 7913 else 7914 { 7915 if (tag & 1) 7916 type = 1; /* String. */ 7917 else 7918 type = 2; /* uleb128. */ 7919 printf (" Tag_unknown_%d: ", tag); 7920 } 7921 7922 if (type == 1) 7923 { 7924 printf ("\"%s\"\n", p); 7925 p += strlen((char *)p) + 1; 7926 } 7927 else 7928 { 7929 val = read_uleb128 (p, &len); 7930 p += len; 7931 printf ("%d (0x%x)\n", val, val); 7932 } 7933 7934 return p; 7935 } 7936 7937 static int 7938 process_arm_specific (FILE *file) 7939 { 7940 Elf_Internal_Shdr *sect; 7941 unsigned char *contents; 7942 unsigned char *p; 7943 unsigned char *end; 7944 bfd_vma section_len; 7945 bfd_vma len; 7946 unsigned i; 7947 7948 /* Find the section header so that we get the size. */ 7949 for (i = 0, sect = section_headers; 7950 i < elf_header.e_shnum; 7951 i++, sect++) 7952 { 7953 if (sect->sh_type != SHT_ARM_ATTRIBUTES) 7954 continue; 7955 7956 contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size, 7957 _("attributes")); 7958 7959 if (!contents) 7960 continue; 7961 p = contents; 7962 if (*p == 'A') 7963 { 7964 len = sect->sh_size - 1; 7965 p++; 7966 while (len > 0) 7967 { 7968 int namelen; 7969 bfd_boolean public_section; 7970 7971 section_len = byte_get (p, 4); 7972 p += 4; 7973 if (section_len > len) 7974 { 7975 printf (_("ERROR: Bad section length (%d > %d)\n"), 7976 (int)section_len, (int)len); 7977 section_len = len; 7978 } 7979 len -= section_len; 7980 printf ("Attribute Section: %s\n", p); 7981 if (strcmp ((char *)p, "aeabi") == 0) 7982 public_section = TRUE; 7983 else 7984 public_section = FALSE; 7985 namelen = strlen ((char *)p) + 1; 7986 p += namelen; 7987 section_len -= namelen + 4; 7988 while (section_len > 0) 7989 { 7990 int tag = *(p++); 7991 int val; 7992 bfd_vma size; 7993 size = byte_get (p, 4); 7994 if (size > section_len) 7995 { 7996 printf (_("ERROR: Bad subsection length (%d > %d)\n"), 7997 (int)size, (int)section_len); 7998 size = section_len; 7999 } 8000 section_len -= size; 8001 end = p + size - 1; 8002 p += 4; 8003 switch (tag) 8004 { 8005 case 1: 8006 printf ("File Attributes\n"); 8007 break; 8008 case 2: 8009 printf ("Section Attributes:"); 8010 goto do_numlist; 8011 case 3: 8012 printf ("Symbol Attributes:"); 8013 do_numlist: 8014 for (;;) 8015 { 8016 unsigned int i; 8017 val = read_uleb128 (p, &i); 8018 p += i; 8019 if (val == 0) 8020 break; 8021 printf (" %d", val); 8022 } 8023 printf ("\n"); 8024 break; 8025 default: 8026 printf ("Unknown tag: %d\n", tag); 8027 public_section = FALSE; 8028 break; 8029 } 8030 if (public_section) 8031 { 8032 while (p < end) 8033 p = display_arm_attribute(p); 8034 } 8035 else 8036 { 8037 /* ??? Do something sensible, like dump hex. */ 8038 printf (" Unknown section contexts\n"); 8039 p = end; 8040 } 8041 } 8042 } 8043 } 8044 else 8045 { 8046 printf (_("Unknown format '%c'\n"), *p); 8047 } 8048 8049 free(contents); 8050 } 8051 return 1; 8052 } 8053 8054 static int 8055 process_mips_specific (FILE *file) 8056 { 8057 Elf_Internal_Dyn *entry; 8058 size_t liblist_offset = 0; 8059 size_t liblistno = 0; 8060 size_t conflictsno = 0; 8061 size_t options_offset = 0; 8062 size_t conflicts_offset = 0; 8063 8064 /* We have a lot of special sections. Thanks SGI! */ 8065 if (dynamic_section == NULL) 8066 /* No information available. */ 8067 return 0; 8068 8069 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry) 8070 switch (entry->d_tag) 8071 { 8072 case DT_MIPS_LIBLIST: 8073 liblist_offset 8074 = offset_from_vma (file, entry->d_un.d_val, 8075 liblistno * sizeof (Elf32_External_Lib)); 8076 break; 8077 case DT_MIPS_LIBLISTNO: 8078 liblistno = entry->d_un.d_val; 8079 break; 8080 case DT_MIPS_OPTIONS: 8081 options_offset = offset_from_vma (file, entry->d_un.d_val, 0); 8082 break; 8083 case DT_MIPS_CONFLICT: 8084 conflicts_offset 8085 = offset_from_vma (file, entry->d_un.d_val, 8086 conflictsno * sizeof (Elf32_External_Conflict)); 8087 break; 8088 case DT_MIPS_CONFLICTNO: 8089 conflictsno = entry->d_un.d_val; 8090 break; 8091 default: 8092 break; 8093 } 8094 8095 if (liblist_offset != 0 && liblistno != 0 && do_dynamic) 8096 { 8097 Elf32_External_Lib *elib; 8098 size_t cnt; 8099 8100 elib = get_data (NULL, file, liblist_offset, 8101 liblistno, sizeof (Elf32_External_Lib), 8102 _("liblist")); 8103 if (elib) 8104 { 8105 printf ("\nSection '.liblist' contains %lu entries:\n", 8106 (unsigned long) liblistno); 8107 fputs (" Library Time Stamp Checksum Version Flags\n", 8108 stdout); 8109 8110 for (cnt = 0; cnt < liblistno; ++cnt) 8111 { 8112 Elf32_Lib liblist; 8113 time_t time; 8114 char timebuf[20]; 8115 struct tm *tmp; 8116 8117 liblist.l_name = BYTE_GET (elib[cnt].l_name); 8118 time = BYTE_GET (elib[cnt].l_time_stamp); 8119 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum); 8120 liblist.l_version = BYTE_GET (elib[cnt].l_version); 8121 liblist.l_flags = BYTE_GET (elib[cnt].l_flags); 8122 8123 tmp = gmtime (&time); 8124 snprintf (timebuf, sizeof (timebuf), 8125 "%04u-%02u-%02uT%02u:%02u:%02u", 8126 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, 8127 tmp->tm_hour, tmp->tm_min, tmp->tm_sec); 8128 8129 printf ("%3lu: ", (unsigned long) cnt); 8130 if (VALID_DYNAMIC_NAME (liblist.l_name)) 8131 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name)); 8132 else 8133 printf ("<corrupt: %9ld>", liblist.l_name); 8134 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum, 8135 liblist.l_version); 8136 8137 if (liblist.l_flags == 0) 8138 puts (" NONE"); 8139 else 8140 { 8141 static const struct 8142 { 8143 const char *name; 8144 int bit; 8145 } 8146 l_flags_vals[] = 8147 { 8148 { " EXACT_MATCH", LL_EXACT_MATCH }, 8149 { " IGNORE_INT_VER", LL_IGNORE_INT_VER }, 8150 { " REQUIRE_MINOR", LL_REQUIRE_MINOR }, 8151 { " EXPORTS", LL_EXPORTS }, 8152 { " DELAY_LOAD", LL_DELAY_LOAD }, 8153 { " DELTA", LL_DELTA } 8154 }; 8155 int flags = liblist.l_flags; 8156 size_t fcnt; 8157 8158 for (fcnt = 0; 8159 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]); 8160 ++fcnt) 8161 if ((flags & l_flags_vals[fcnt].bit) != 0) 8162 { 8163 fputs (l_flags_vals[fcnt].name, stdout); 8164 flags ^= l_flags_vals[fcnt].bit; 8165 } 8166 if (flags != 0) 8167 printf (" %#x", (unsigned int) flags); 8168 8169 puts (""); 8170 } 8171 } 8172 8173 free (elib); 8174 } 8175 } 8176 8177 if (options_offset != 0) 8178 { 8179 Elf_External_Options *eopt; 8180 Elf_Internal_Shdr *sect = section_headers; 8181 Elf_Internal_Options *iopt; 8182 Elf_Internal_Options *option; 8183 size_t offset; 8184 int cnt; 8185 8186 /* Find the section header so that we get the size. */ 8187 while (sect->sh_type != SHT_MIPS_OPTIONS) 8188 ++sect; 8189 8190 eopt = get_data (NULL, file, options_offset, 1, sect->sh_size, 8191 _("options")); 8192 if (eopt) 8193 { 8194 iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt)); 8195 if (iopt == NULL) 8196 { 8197 error (_("Out of memory")); 8198 return 0; 8199 } 8200 8201 offset = cnt = 0; 8202 option = iopt; 8203 8204 while (offset < sect->sh_size) 8205 { 8206 Elf_External_Options *eoption; 8207 8208 eoption = (Elf_External_Options *) ((char *) eopt + offset); 8209 8210 option->kind = BYTE_GET (eoption->kind); 8211 option->size = BYTE_GET (eoption->size); 8212 option->section = BYTE_GET (eoption->section); 8213 option->info = BYTE_GET (eoption->info); 8214 8215 offset += option->size; 8216 8217 ++option; 8218 ++cnt; 8219 } 8220 8221 printf (_("\nSection '%s' contains %d entries:\n"), 8222 SECTION_NAME (sect), cnt); 8223 8224 option = iopt; 8225 8226 while (cnt-- > 0) 8227 { 8228 size_t len; 8229 8230 switch (option->kind) 8231 { 8232 case ODK_NULL: 8233 /* This shouldn't happen. */ 8234 printf (" NULL %d %lx", option->section, option->info); 8235 break; 8236 case ODK_REGINFO: 8237 printf (" REGINFO "); 8238 if (elf_header.e_machine == EM_MIPS) 8239 { 8240 /* 32bit form. */ 8241 Elf32_External_RegInfo *ereg; 8242 Elf32_RegInfo reginfo; 8243 8244 ereg = (Elf32_External_RegInfo *) (option + 1); 8245 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask); 8246 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]); 8247 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]); 8248 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]); 8249 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]); 8250 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value); 8251 8252 printf ("GPR %08lx GP 0x%lx\n", 8253 reginfo.ri_gprmask, 8254 (unsigned long) reginfo.ri_gp_value); 8255 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n", 8256 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1], 8257 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]); 8258 } 8259 else 8260 { 8261 /* 64 bit form. */ 8262 Elf64_External_RegInfo *ereg; 8263 Elf64_Internal_RegInfo reginfo; 8264 8265 ereg = (Elf64_External_RegInfo *) (option + 1); 8266 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask); 8267 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]); 8268 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]); 8269 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]); 8270 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]); 8271 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value); 8272 8273 printf ("GPR %08lx GP 0x", 8274 reginfo.ri_gprmask); 8275 printf_vma (reginfo.ri_gp_value); 8276 printf ("\n"); 8277 8278 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n", 8279 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1], 8280 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]); 8281 } 8282 ++option; 8283 continue; 8284 case ODK_EXCEPTIONS: 8285 fputs (" EXCEPTIONS fpe_min(", stdout); 8286 process_mips_fpe_exception (option->info & OEX_FPU_MIN); 8287 fputs (") fpe_max(", stdout); 8288 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8); 8289 fputs (")", stdout); 8290 8291 if (option->info & OEX_PAGE0) 8292 fputs (" PAGE0", stdout); 8293 if (option->info & OEX_SMM) 8294 fputs (" SMM", stdout); 8295 if (option->info & OEX_FPDBUG) 8296 fputs (" FPDBUG", stdout); 8297 if (option->info & OEX_DISMISS) 8298 fputs (" DISMISS", stdout); 8299 break; 8300 case ODK_PAD: 8301 fputs (" PAD ", stdout); 8302 if (option->info & OPAD_PREFIX) 8303 fputs (" PREFIX", stdout); 8304 if (option->info & OPAD_POSTFIX) 8305 fputs (" POSTFIX", stdout); 8306 if (option->info & OPAD_SYMBOL) 8307 fputs (" SYMBOL", stdout); 8308 break; 8309 case ODK_HWPATCH: 8310 fputs (" HWPATCH ", stdout); 8311 if (option->info & OHW_R4KEOP) 8312 fputs (" R4KEOP", stdout); 8313 if (option->info & OHW_R8KPFETCH) 8314 fputs (" R8KPFETCH", stdout); 8315 if (option->info & OHW_R5KEOP) 8316 fputs (" R5KEOP", stdout); 8317 if (option->info & OHW_R5KCVTL) 8318 fputs (" R5KCVTL", stdout); 8319 break; 8320 case ODK_FILL: 8321 fputs (" FILL ", stdout); 8322 /* XXX Print content of info word? */ 8323 break; 8324 case ODK_TAGS: 8325 fputs (" TAGS ", stdout); 8326 /* XXX Print content of info word? */ 8327 break; 8328 case ODK_HWAND: 8329 fputs (" HWAND ", stdout); 8330 if (option->info & OHWA0_R4KEOP_CHECKED) 8331 fputs (" R4KEOP_CHECKED", stdout); 8332 if (option->info & OHWA0_R4KEOP_CLEAN) 8333 fputs (" R4KEOP_CLEAN", stdout); 8334 break; 8335 case ODK_HWOR: 8336 fputs (" HWOR ", stdout); 8337 if (option->info & OHWA0_R4KEOP_CHECKED) 8338 fputs (" R4KEOP_CHECKED", stdout); 8339 if (option->info & OHWA0_R4KEOP_CLEAN) 8340 fputs (" R4KEOP_CLEAN", stdout); 8341 break; 8342 case ODK_GP_GROUP: 8343 printf (" GP_GROUP %#06lx self-contained %#06lx", 8344 option->info & OGP_GROUP, 8345 (option->info & OGP_SELF) >> 16); 8346 break; 8347 case ODK_IDENT: 8348 printf (" IDENT %#06lx self-contained %#06lx", 8349 option->info & OGP_GROUP, 8350 (option->info & OGP_SELF) >> 16); 8351 break; 8352 default: 8353 /* This shouldn't happen. */ 8354 printf (" %3d ??? %d %lx", 8355 option->kind, option->section, option->info); 8356 break; 8357 } 8358 8359 len = sizeof (*eopt); 8360 while (len < option->size) 8361 if (((char *) option)[len] >= ' ' 8362 && ((char *) option)[len] < 0x7f) 8363 printf ("%c", ((char *) option)[len++]); 8364 else 8365 printf ("\\%03o", ((char *) option)[len++]); 8366 8367 fputs ("\n", stdout); 8368 ++option; 8369 } 8370 8371 free (eopt); 8372 } 8373 } 8374 8375 if (conflicts_offset != 0 && conflictsno != 0) 8376 { 8377 Elf32_Conflict *iconf; 8378 size_t cnt; 8379 8380 if (dynamic_symbols == NULL) 8381 { 8382 error (_("conflict list found without a dynamic symbol table")); 8383 return 0; 8384 } 8385 8386 iconf = cmalloc (conflictsno, sizeof (*iconf)); 8387 if (iconf == NULL) 8388 { 8389 error (_("Out of memory")); 8390 return 0; 8391 } 8392 8393 if (is_32bit_elf) 8394 { 8395 Elf32_External_Conflict *econf32; 8396 8397 econf32 = get_data (NULL, file, conflicts_offset, 8398 conflictsno, sizeof (*econf32), _("conflict")); 8399 if (!econf32) 8400 return 0; 8401 8402 for (cnt = 0; cnt < conflictsno; ++cnt) 8403 iconf[cnt] = BYTE_GET (econf32[cnt]); 8404 8405 free (econf32); 8406 } 8407 else 8408 { 8409 Elf64_External_Conflict *econf64; 8410 8411 econf64 = get_data (NULL, file, conflicts_offset, 8412 conflictsno, sizeof (*econf64), _("conflict")); 8413 if (!econf64) 8414 return 0; 8415 8416 for (cnt = 0; cnt < conflictsno; ++cnt) 8417 iconf[cnt] = BYTE_GET (econf64[cnt]); 8418 8419 free (econf64); 8420 } 8421 8422 printf (_("\nSection '.conflict' contains %lu entries:\n"), 8423 (unsigned long) conflictsno); 8424 puts (_(" Num: Index Value Name")); 8425 8426 for (cnt = 0; cnt < conflictsno; ++cnt) 8427 { 8428 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]]; 8429 8430 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]); 8431 print_vma (psym->st_value, FULL_HEX); 8432 putchar (' '); 8433 if (VALID_DYNAMIC_NAME (psym->st_name)) 8434 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name)); 8435 else 8436 printf ("<corrupt: %14ld>", psym->st_name); 8437 putchar ('\n'); 8438 } 8439 8440 free (iconf); 8441 } 8442 8443 return 1; 8444 } 8445 8446 static int 8447 process_gnu_liblist (FILE *file) 8448 { 8449 Elf_Internal_Shdr *section, *string_sec; 8450 Elf32_External_Lib *elib; 8451 char *strtab; 8452 size_t strtab_size; 8453 size_t cnt; 8454 unsigned i; 8455 8456 if (! do_arch) 8457 return 0; 8458 8459 for (i = 0, section = section_headers; 8460 i < elf_header.e_shnum; 8461 i++, section++) 8462 { 8463 switch (section->sh_type) 8464 { 8465 case SHT_GNU_LIBLIST: 8466 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum) 8467 break; 8468 8469 elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size, 8470 _("liblist")); 8471 8472 if (elib == NULL) 8473 break; 8474 string_sec = SECTION_HEADER (section->sh_link); 8475 8476 strtab = get_data (NULL, file, string_sec->sh_offset, 1, 8477 string_sec->sh_size, _("liblist string table")); 8478 strtab_size = string_sec->sh_size; 8479 8480 if (strtab == NULL 8481 || section->sh_entsize != sizeof (Elf32_External_Lib)) 8482 { 8483 free (elib); 8484 break; 8485 } 8486 8487 printf (_("\nLibrary list section '%s' contains %lu entries:\n"), 8488 SECTION_NAME (section), 8489 (long) (section->sh_size / sizeof (Elf32_External_Lib))); 8490 8491 puts (" Library Time Stamp Checksum Version Flags"); 8492 8493 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib); 8494 ++cnt) 8495 { 8496 Elf32_Lib liblist; 8497 time_t time; 8498 char timebuf[20]; 8499 struct tm *tmp; 8500 8501 liblist.l_name = BYTE_GET (elib[cnt].l_name); 8502 time = BYTE_GET (elib[cnt].l_time_stamp); 8503 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum); 8504 liblist.l_version = BYTE_GET (elib[cnt].l_version); 8505 liblist.l_flags = BYTE_GET (elib[cnt].l_flags); 8506 8507 tmp = gmtime (&time); 8508 snprintf (timebuf, sizeof (timebuf), 8509 "%04u-%02u-%02uT%02u:%02u:%02u", 8510 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, 8511 tmp->tm_hour, tmp->tm_min, tmp->tm_sec); 8512 8513 printf ("%3lu: ", (unsigned long) cnt); 8514 if (do_wide) 8515 printf ("%-20s", liblist.l_name < strtab_size 8516 ? strtab + liblist.l_name : "<corrupt>"); 8517 else 8518 printf ("%-20.20s", liblist.l_name < strtab_size 8519 ? strtab + liblist.l_name : "<corrupt>"); 8520 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum, 8521 liblist.l_version, liblist.l_flags); 8522 } 8523 8524 free (elib); 8525 } 8526 } 8527 8528 return 1; 8529 } 8530 8531 static const char * 8532 get_note_type (unsigned e_type) 8533 { 8534 static char buff[64]; 8535 8536 if (elf_header.e_type == ET_CORE) 8537 switch (e_type) 8538 { 8539 case NT_AUXV: 8540 return _("NT_AUXV (auxiliary vector)"); 8541 case NT_PRSTATUS: 8542 return _("NT_PRSTATUS (prstatus structure)"); 8543 case NT_FPREGSET: 8544 return _("NT_FPREGSET (floating point registers)"); 8545 case NT_PRPSINFO: 8546 return _("NT_PRPSINFO (prpsinfo structure)"); 8547 case NT_TASKSTRUCT: 8548 return _("NT_TASKSTRUCT (task structure)"); 8549 case NT_PRXFPREG: 8550 return _("NT_PRXFPREG (user_xfpregs structure)"); 8551 case NT_PSTATUS: 8552 return _("NT_PSTATUS (pstatus structure)"); 8553 case NT_FPREGS: 8554 return _("NT_FPREGS (floating point registers)"); 8555 case NT_PSINFO: 8556 return _("NT_PSINFO (psinfo structure)"); 8557 case NT_LWPSTATUS: 8558 return _("NT_LWPSTATUS (lwpstatus_t structure)"); 8559 case NT_LWPSINFO: 8560 return _("NT_LWPSINFO (lwpsinfo_t structure)"); 8561 case NT_WIN32PSTATUS: 8562 return _("NT_WIN32PSTATUS (win32_pstatus structure)"); 8563 default: 8564 break; 8565 } 8566 else 8567 switch (e_type) 8568 { 8569 case NT_VERSION: 8570 return _("NT_VERSION (version)"); 8571 case NT_ARCH: 8572 return _("NT_ARCH (architecture)"); 8573 default: 8574 break; 8575 } 8576 8577 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type); 8578 return buff; 8579 } 8580 8581 static const char * 8582 get_netbsd_elfcore_note_type (unsigned e_type) 8583 { 8584 static char buff[64]; 8585 8586 if (e_type == NT_NETBSDCORE_PROCINFO) 8587 { 8588 /* NetBSD core "procinfo" structure. */ 8589 return _("NetBSD procinfo structure"); 8590 } 8591 8592 /* As of Jan 2002 there are no other machine-independent notes 8593 defined for NetBSD core files. If the note type is less 8594 than the start of the machine-dependent note types, we don't 8595 understand it. */ 8596 8597 if (e_type < NT_NETBSDCORE_FIRSTMACH) 8598 { 8599 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type); 8600 return buff; 8601 } 8602 8603 switch (elf_header.e_machine) 8604 { 8605 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 8606 and PT_GETFPREGS == mach+2. */ 8607 8608 case EM_OLD_ALPHA: 8609 case EM_ALPHA: 8610 case EM_SPARC: 8611 case EM_SPARC32PLUS: 8612 case EM_SPARCV9: 8613 switch (e_type) 8614 { 8615 case NT_NETBSDCORE_FIRSTMACH+0: 8616 return _("PT_GETREGS (reg structure)"); 8617 case NT_NETBSDCORE_FIRSTMACH+2: 8618 return _("PT_GETFPREGS (fpreg structure)"); 8619 default: 8620 break; 8621 } 8622 break; 8623 8624 /* On all other arch's, PT_GETREGS == mach+1 and 8625 PT_GETFPREGS == mach+3. */ 8626 default: 8627 switch (e_type) 8628 { 8629 case NT_NETBSDCORE_FIRSTMACH+1: 8630 return _("PT_GETREGS (reg structure)"); 8631 case NT_NETBSDCORE_FIRSTMACH+3: 8632 return _("PT_GETFPREGS (fpreg structure)"); 8633 default: 8634 break; 8635 } 8636 } 8637 8638 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"), 8639 e_type - NT_NETBSDCORE_FIRSTMACH); 8640 return buff; 8641 } 8642 8643 /* Note that by the ELF standard, the name field is already null byte 8644 terminated, and namesz includes the terminating null byte. 8645 I.E. the value of namesz for the name "FSF" is 4. 8646 8647 If the value of namesz is zero, there is no name present. */ 8648 static int 8649 process_note (Elf_Internal_Note *pnote) 8650 { 8651 const char *nt; 8652 8653 if (pnote->namesz == 0) 8654 /* If there is no note name, then use the default set of 8655 note type strings. */ 8656 nt = get_note_type (pnote->type); 8657 8658 else if (strneq (pnote->namedata, "NetBSD-CORE", 11)) 8659 /* NetBSD-specific core file notes. */ 8660 nt = get_netbsd_elfcore_note_type (pnote->type); 8661 8662 else 8663 /* Don't recognize this note name; just use the default set of 8664 note type strings. */ 8665 nt = get_note_type (pnote->type); 8666 8667 printf (" %s\t\t0x%08lx\t%s\n", 8668 pnote->namesz ? pnote->namedata : "(NONE)", 8669 pnote->descsz, nt); 8670 return 1; 8671 } 8672 8673 8674 static int 8675 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length) 8676 { 8677 Elf_External_Note *pnotes; 8678 Elf_External_Note *external; 8679 int res = 1; 8680 8681 if (length <= 0) 8682 return 0; 8683 8684 pnotes = get_data (NULL, file, offset, 1, length, _("notes")); 8685 if (!pnotes) 8686 return 0; 8687 8688 external = pnotes; 8689 8690 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"), 8691 (unsigned long) offset, (unsigned long) length); 8692 printf (_(" Owner\t\tData size\tDescription\n")); 8693 8694 while (external < (Elf_External_Note *)((char *) pnotes + length)) 8695 { 8696 Elf_External_Note *next; 8697 Elf_Internal_Note inote; 8698 char *temp = NULL; 8699 8700 inote.type = BYTE_GET (external->type); 8701 inote.namesz = BYTE_GET (external->namesz); 8702 inote.namedata = external->name; 8703 inote.descsz = BYTE_GET (external->descsz); 8704 inote.descdata = inote.namedata + align_power (inote.namesz, 2); 8705 inote.descpos = offset + (inote.descdata - (char *) pnotes); 8706 8707 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2)); 8708 8709 if (((char *) next) > (((char *) pnotes) + length)) 8710 { 8711 warn (_("corrupt note found at offset %lx into core notes\n"), 8712 (long)((char *)external - (char *)pnotes)); 8713 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"), 8714 inote.type, inote.namesz, inote.descsz); 8715 break; 8716 } 8717 8718 external = next; 8719 8720 /* Verify that name is null terminated. It appears that at least 8721 one version of Linux (RedHat 6.0) generates corefiles that don't 8722 comply with the ELF spec by failing to include the null byte in 8723 namesz. */ 8724 if (inote.namedata[inote.namesz] != '\0') 8725 { 8726 temp = malloc (inote.namesz + 1); 8727 8728 if (temp == NULL) 8729 { 8730 error (_("Out of memory\n")); 8731 res = 0; 8732 break; 8733 } 8734 8735 strncpy (temp, inote.namedata, inote.namesz); 8736 temp[inote.namesz] = 0; 8737 8738 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */ 8739 inote.namedata = temp; 8740 } 8741 8742 res &= process_note (& inote); 8743 8744 if (temp != NULL) 8745 { 8746 free (temp); 8747 temp = NULL; 8748 } 8749 } 8750 8751 free (pnotes); 8752 8753 return res; 8754 } 8755 8756 static int 8757 process_corefile_note_segments (FILE *file) 8758 { 8759 Elf_Internal_Phdr *segment; 8760 unsigned int i; 8761 int res = 1; 8762 8763 if (! get_program_headers (file)) 8764 return 0; 8765 8766 for (i = 0, segment = program_headers; 8767 i < elf_header.e_phnum; 8768 i++, segment++) 8769 { 8770 if (segment->p_type == PT_NOTE) 8771 res &= process_corefile_note_segment (file, 8772 (bfd_vma) segment->p_offset, 8773 (bfd_vma) segment->p_filesz); 8774 } 8775 8776 return res; 8777 } 8778 8779 static int 8780 process_note_sections (FILE *file) 8781 { 8782 Elf_Internal_Shdr *section; 8783 unsigned long i; 8784 int res = 1; 8785 8786 for (i = 0, section = section_headers; 8787 i < elf_header.e_shnum; 8788 i++, section++) 8789 if (section->sh_type == SHT_NOTE) 8790 res &= process_corefile_note_segment (file, 8791 (bfd_vma) section->sh_offset, 8792 (bfd_vma) section->sh_size); 8793 8794 return res; 8795 } 8796 8797 static int 8798 process_notes (FILE *file) 8799 { 8800 /* If we have not been asked to display the notes then do nothing. */ 8801 if (! do_notes) 8802 return 1; 8803 8804 if (elf_header.e_type != ET_CORE) 8805 return process_note_sections (file); 8806 8807 /* No program headers means no NOTE segment. */ 8808 if (elf_header.e_phnum > 0) 8809 return process_corefile_note_segments (file); 8810 8811 printf (_("No note segments present in the core file.\n")); 8812 return 1; 8813 } 8814 8815 static int 8816 process_arch_specific (FILE *file) 8817 { 8818 if (! do_arch) 8819 return 1; 8820 8821 switch (elf_header.e_machine) 8822 { 8823 case EM_ARM: 8824 return process_arm_specific (file); 8825 case EM_MIPS: 8826 case EM_MIPS_RS3_LE: 8827 return process_mips_specific (file); 8828 break; 8829 default: 8830 break; 8831 } 8832 return 1; 8833 } 8834 8835 static int 8836 get_file_header (FILE *file) 8837 { 8838 /* Read in the identity array. */ 8839 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1) 8840 return 0; 8841 8842 /* Determine how to read the rest of the header. */ 8843 switch (elf_header.e_ident[EI_DATA]) 8844 { 8845 default: /* fall through */ 8846 case ELFDATANONE: /* fall through */ 8847 case ELFDATA2LSB: 8848 byte_get = byte_get_little_endian; 8849 byte_put = byte_put_little_endian; 8850 break; 8851 case ELFDATA2MSB: 8852 byte_get = byte_get_big_endian; 8853 byte_put = byte_put_big_endian; 8854 break; 8855 } 8856 8857 /* For now we only support 32 bit and 64 bit ELF files. */ 8858 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64); 8859 8860 /* Read in the rest of the header. */ 8861 if (is_32bit_elf) 8862 { 8863 Elf32_External_Ehdr ehdr32; 8864 /* Temporary var to prevent the GCC -Wbounded checker from firing. */ 8865 void *tmp = &ehdr32.e_type[0]; 8866 8867 if (fread (tmp, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1) 8868 return 0; 8869 8870 elf_header.e_type = BYTE_GET (ehdr32.e_type); 8871 elf_header.e_machine = BYTE_GET (ehdr32.e_machine); 8872 elf_header.e_version = BYTE_GET (ehdr32.e_version); 8873 elf_header.e_entry = BYTE_GET (ehdr32.e_entry); 8874 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff); 8875 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff); 8876 elf_header.e_flags = BYTE_GET (ehdr32.e_flags); 8877 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize); 8878 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize); 8879 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum); 8880 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize); 8881 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum); 8882 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx); 8883 } 8884 else 8885 { 8886 Elf64_External_Ehdr ehdr64; 8887 /* Temporary var to prevent the GCC -Wbounded checker from firing. */ 8888 void *tmp = &ehdr64.e_type[0]; 8889 8890 /* If we have been compiled with sizeof (bfd_vma) == 4, then 8891 we will not be able to cope with the 64bit data found in 8892 64 ELF files. Detect this now and abort before we start 8893 overwriting things. */ 8894 if (sizeof (bfd_vma) < 8) 8895 { 8896 error (_("This instance of readelf has been built without support for a\n\ 8897 64 bit data type and so it cannot read 64 bit ELF files.\n")); 8898 return 0; 8899 } 8900 8901 if (fread (tmp, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1) 8902 return 0; 8903 8904 elf_header.e_type = BYTE_GET (ehdr64.e_type); 8905 elf_header.e_machine = BYTE_GET (ehdr64.e_machine); 8906 elf_header.e_version = BYTE_GET (ehdr64.e_version); 8907 elf_header.e_entry = BYTE_GET (ehdr64.e_entry); 8908 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff); 8909 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff); 8910 elf_header.e_flags = BYTE_GET (ehdr64.e_flags); 8911 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize); 8912 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize); 8913 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum); 8914 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize); 8915 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum); 8916 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx); 8917 } 8918 8919 if (elf_header.e_shoff) 8920 { 8921 /* There may be some extensions in the first section header. Don't 8922 bomb if we can't read it. */ 8923 if (is_32bit_elf) 8924 get_32bit_section_headers (file, 1); 8925 else 8926 get_64bit_section_headers (file, 1); 8927 } 8928 8929 is_relocatable = elf_header.e_type == ET_REL; 8930 8931 return 1; 8932 } 8933 8934 /* Process one ELF object file according to the command line options. 8935 This file may actually be stored in an archive. The file is 8936 positioned at the start of the ELF object. */ 8937 8938 static int 8939 process_object (char *file_name, FILE *file) 8940 { 8941 unsigned int i; 8942 8943 if (! get_file_header (file)) 8944 { 8945 error (_("%s: Failed to read file header\n"), file_name); 8946 return 1; 8947 } 8948 8949 /* Initialise per file variables. */ 8950 for (i = NUM_ELEM (version_info); i--;) 8951 version_info[i] = 0; 8952 8953 for (i = NUM_ELEM (dynamic_info); i--;) 8954 dynamic_info[i] = 0; 8955 8956 /* Process the file. */ 8957 if (show_name) 8958 printf (_("\nFile: %s\n"), file_name); 8959 8960 /* Initialise the dump_sects array from the cmdline_dump_sects array. 8961 Note we do this even if cmdline_dump_sects is empty because we 8962 must make sure that the dump_sets array is zeroed out before each 8963 object file is processed. */ 8964 if (num_dump_sects > num_cmdline_dump_sects) 8965 memset (dump_sects, 0, num_dump_sects); 8966 8967 if (num_cmdline_dump_sects > 0) 8968 { 8969 if (num_dump_sects == 0) 8970 /* A sneaky way of allocating the dump_sects array. */ 8971 request_dump (num_cmdline_dump_sects, 0); 8972 8973 assert (num_dump_sects >= num_cmdline_dump_sects); 8974 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects); 8975 } 8976 8977 if (! process_file_header ()) 8978 return 1; 8979 8980 if (! process_section_headers (file)) 8981 { 8982 /* Without loaded section headers we cannot process lots of 8983 things. */ 8984 do_unwind = do_version = do_dump = do_arch = 0; 8985 8986 if (! do_using_dynamic) 8987 do_syms = do_reloc = 0; 8988 } 8989 8990 if (! process_section_groups (file)) 8991 { 8992 /* Without loaded section groups we cannot process unwind. */ 8993 do_unwind = 0; 8994 } 8995 8996 if (process_program_headers (file)) 8997 process_dynamic_section (file); 8998 8999 process_relocs (file); 9000 9001 process_unwind (file); 9002 9003 process_symbol_table (file); 9004 9005 process_syminfo (file); 9006 9007 process_version_sections (file); 9008 9009 process_section_contents (file); 9010 9011 process_notes (file); 9012 9013 process_gnu_liblist (file); 9014 9015 process_arch_specific (file); 9016 9017 if (program_headers) 9018 { 9019 free (program_headers); 9020 program_headers = NULL; 9021 } 9022 9023 if (section_headers) 9024 { 9025 free (section_headers); 9026 section_headers = NULL; 9027 } 9028 9029 if (string_table) 9030 { 9031 free (string_table); 9032 string_table = NULL; 9033 string_table_length = 0; 9034 } 9035 9036 if (dynamic_strings) 9037 { 9038 free (dynamic_strings); 9039 dynamic_strings = NULL; 9040 dynamic_strings_length = 0; 9041 } 9042 9043 if (dynamic_symbols) 9044 { 9045 free (dynamic_symbols); 9046 dynamic_symbols = NULL; 9047 num_dynamic_syms = 0; 9048 } 9049 9050 if (dynamic_syminfo) 9051 { 9052 free (dynamic_syminfo); 9053 dynamic_syminfo = NULL; 9054 } 9055 9056 if (section_headers_groups) 9057 { 9058 free (section_headers_groups); 9059 section_headers_groups = NULL; 9060 } 9061 9062 if (section_groups) 9063 { 9064 struct group_list *g, *next; 9065 9066 for (i = 0; i < group_count; i++) 9067 { 9068 for (g = section_groups [i].root; g != NULL; g = next) 9069 { 9070 next = g->next; 9071 free (g); 9072 } 9073 } 9074 9075 free (section_groups); 9076 section_groups = NULL; 9077 } 9078 9079 free_debug_memory (); 9080 9081 return 0; 9082 } 9083 9084 /* Process an ELF archive. The file is positioned just after the 9085 ARMAG string. */ 9086 9087 static int 9088 process_archive (char *file_name, FILE *file) 9089 { 9090 struct ar_hdr arhdr; 9091 size_t got; 9092 unsigned long size; 9093 char *longnames = NULL; 9094 unsigned long longnames_size = 0; 9095 size_t file_name_size; 9096 int ret; 9097 9098 show_name = 1; 9099 9100 got = fread (&arhdr, 1, sizeof arhdr, file); 9101 if (got != sizeof arhdr) 9102 { 9103 if (got == 0) 9104 return 0; 9105 9106 error (_("%s: failed to read archive header\n"), file_name); 9107 return 1; 9108 } 9109 9110 if (memcmp (arhdr.ar_name, "/ ", 16) == 0) 9111 { 9112 /* This is the archive symbol table. Skip it. 9113 FIXME: We should have an option to dump it. */ 9114 size = strtoul (arhdr.ar_size, NULL, 10); 9115 if (fseek (file, size + (size & 1), SEEK_CUR) != 0) 9116 { 9117 error (_("%s: failed to skip archive symbol table\n"), file_name); 9118 return 1; 9119 } 9120 9121 got = fread (&arhdr, 1, sizeof arhdr, file); 9122 if (got != sizeof arhdr) 9123 { 9124 if (got == 0) 9125 return 0; 9126 9127 error (_("%s: failed to read archive header\n"), file_name); 9128 return 1; 9129 } 9130 } 9131 9132 if (memcmp (arhdr.ar_name, "// ", 16) == 0) 9133 { 9134 /* This is the archive string table holding long member 9135 names. */ 9136 9137 longnames_size = strtoul (arhdr.ar_size, NULL, 10); 9138 9139 longnames = malloc (longnames_size); 9140 if (longnames == NULL) 9141 { 9142 error (_("Out of memory\n")); 9143 return 1; 9144 } 9145 9146 if (fread (longnames, longnames_size, 1, file) != 1) 9147 { 9148 free (longnames); 9149 error (_("%s: failed to read string table\n"), file_name); 9150 return 1; 9151 } 9152 9153 if ((longnames_size & 1) != 0) 9154 getc (file); 9155 9156 got = fread (&arhdr, 1, sizeof arhdr, file); 9157 if (got != sizeof arhdr) 9158 { 9159 free (longnames); 9160 9161 if (got == 0) 9162 return 0; 9163 9164 error (_("%s: failed to read archive header\n"), file_name); 9165 return 1; 9166 } 9167 } 9168 9169 file_name_size = strlen (file_name); 9170 ret = 0; 9171 9172 while (1) 9173 { 9174 char *name; 9175 char *nameend; 9176 char *namealc; 9177 9178 if (arhdr.ar_name[0] == '/') 9179 { 9180 unsigned long off; 9181 9182 off = strtoul (arhdr.ar_name + 1, NULL, 10); 9183 if (off >= longnames_size) 9184 { 9185 error (_("%s: invalid archive string table offset %lu\n"), file_name, off); 9186 ret = 1; 9187 break; 9188 } 9189 9190 name = longnames + off; 9191 nameend = memchr (name, '/', longnames_size - off); 9192 } 9193 else 9194 { 9195 name = arhdr.ar_name; 9196 nameend = memchr (name, '/', 16); 9197 } 9198 9199 if (nameend == NULL) 9200 { 9201 error (_("%s: bad archive file name\n"), file_name); 9202 ret = 1; 9203 break; 9204 } 9205 9206 namealc = malloc (file_name_size + (nameend - name) + 3); 9207 if (namealc == NULL) 9208 { 9209 error (_("Out of memory\n")); 9210 ret = 1; 9211 break; 9212 } 9213 9214 memcpy (namealc, file_name, file_name_size); 9215 namealc[file_name_size] = '('; 9216 memcpy (namealc + file_name_size + 1, name, nameend - name); 9217 namealc[file_name_size + 1 + (nameend - name)] = ')'; 9218 namealc[file_name_size + 2 + (nameend - name)] = '\0'; 9219 9220 archive_file_offset = ftell (file); 9221 archive_file_size = strtoul (arhdr.ar_size, NULL, 10); 9222 9223 ret |= process_object (namealc, file); 9224 9225 free (namealc); 9226 9227 if (fseek (file, 9228 (archive_file_offset 9229 + archive_file_size 9230 + (archive_file_size & 1)), 9231 SEEK_SET) != 0) 9232 { 9233 error (_("%s: failed to seek to next archive header\n"), file_name); 9234 ret = 1; 9235 break; 9236 } 9237 9238 got = fread (&arhdr, 1, sizeof arhdr, file); 9239 if (got != sizeof arhdr) 9240 { 9241 if (got == 0) 9242 break; 9243 9244 error (_("%s: failed to read archive header\n"), file_name); 9245 ret = 1; 9246 break; 9247 } 9248 } 9249 9250 if (longnames != 0) 9251 free (longnames); 9252 9253 return ret; 9254 } 9255 9256 static int 9257 process_file (char *file_name) 9258 { 9259 FILE *file; 9260 struct stat statbuf; 9261 char armag[SARMAG]; 9262 int ret; 9263 9264 if (stat (file_name, &statbuf) < 0) 9265 { 9266 if (errno == ENOENT) 9267 error (_("'%s': No such file\n"), file_name); 9268 else 9269 error (_("Could not locate '%s'. System error message: %s\n"), 9270 file_name, strerror (errno)); 9271 return 1; 9272 } 9273 9274 if (! S_ISREG (statbuf.st_mode)) 9275 { 9276 error (_("'%s' is not an ordinary file\n"), file_name); 9277 return 1; 9278 } 9279 9280 file = fopen (file_name, "rb"); 9281 if (file == NULL) 9282 { 9283 error (_("Input file '%s' is not readable.\n"), file_name); 9284 return 1; 9285 } 9286 9287 if (fread (armag, SARMAG, 1, file) != 1) 9288 { 9289 error (_("%s: Failed to read file header\n"), file_name); 9290 fclose (file); 9291 return 1; 9292 } 9293 9294 if (memcmp (armag, ARMAG, SARMAG) == 0) 9295 ret = process_archive (file_name, file); 9296 else 9297 { 9298 rewind (file); 9299 archive_file_size = archive_file_offset = 0; 9300 ret = process_object (file_name, file); 9301 } 9302 9303 fclose (file); 9304 9305 return ret; 9306 } 9307 9308 #ifdef SUPPORT_DISASSEMBLY 9309 /* Needed by the i386 disassembler. For extra credit, someone could 9310 fix this so that we insert symbolic addresses here, esp for GOT/PLT 9311 symbols. */ 9312 9313 void 9314 print_address (unsigned int addr, FILE *outfile) 9315 { 9316 fprintf (outfile,"0x%8.8x", addr); 9317 } 9318 9319 /* Needed by the i386 disassembler. */ 9320 void 9321 db_task_printsym (unsigned int addr) 9322 { 9323 print_address (addr, stderr); 9324 } 9325 #endif 9326 9327 int 9328 main (int argc, char **argv) 9329 { 9330 int err; 9331 9332 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 9333 setlocale (LC_MESSAGES, ""); 9334 #endif 9335 #if defined (HAVE_SETLOCALE) 9336 setlocale (LC_CTYPE, ""); 9337 #endif 9338 bindtextdomain (PACKAGE, LOCALEDIR); 9339 textdomain (PACKAGE); 9340 9341 expandargv (&argc, &argv); 9342 9343 parse_args (argc, argv); 9344 9345 if (num_dump_sects > 0) 9346 { 9347 /* Make a copy of the dump_sects array. */ 9348 cmdline_dump_sects = malloc (num_dump_sects); 9349 if (cmdline_dump_sects == NULL) 9350 error (_("Out of memory allocating dump request table.")); 9351 else 9352 { 9353 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects); 9354 num_cmdline_dump_sects = num_dump_sects; 9355 } 9356 } 9357 9358 if (optind < (argc - 1)) 9359 show_name = 1; 9360 9361 err = 0; 9362 while (optind < argc) 9363 err |= process_file (argv[optind++]); 9364 9365 if (dump_sects != NULL) 9366 free (dump_sects); 9367 if (cmdline_dump_sects != NULL) 9368 free (cmdline_dump_sects); 9369 9370 return err; 9371 } 9372