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