1 /* objdump.c -- dump information about an object file. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 4 2012 Free Software Foundation, Inc. 5 6 This file is part of GNU Binutils. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 24 /* Objdump overview. 25 26 Objdump displays information about one or more object files, either on 27 their own, or inside libraries. It is commonly used as a disassembler, 28 but it can also display information about file headers, symbol tables, 29 relocations, debugging directives and more. 30 31 The flow of execution is as follows: 32 33 1. Command line arguments are checked for control switches and the 34 information to be displayed is selected. 35 36 2. Any remaining arguments are assumed to be object files, and they are 37 processed in order by display_bfd(). If the file is an archive each 38 of its elements is processed in turn. 39 40 3. The file's target architecture and binary file format are determined 41 by bfd_check_format(). If they are recognised, then dump_bfd() is 42 called. 43 44 4. dump_bfd() in turn calls separate functions to display the requested 45 item(s) of information(s). For example disassemble_data() is called if 46 a disassembly has been requested. 47 48 When disassembling the code loops through blocks of instructions bounded 49 by symbols, calling disassemble_bytes() on each block. The actual 50 disassembling is done by the libopcodes library, via a function pointer 51 supplied by the disassembler() function. */ 52 53 #include "sysdep.h" 54 #include "bfd.h" 55 #include "elf-bfd.h" 56 #include "progress.h" 57 #include "bucomm.h" 58 #include "elfcomm.h" 59 #include "dwarf.h" 60 #include "getopt.h" 61 #include "safe-ctype.h" 62 #include "dis-asm.h" 63 #include "libiberty.h" 64 #include "demangle.h" 65 #include "filenames.h" 66 #include "debug.h" 67 #include "budbg.h" 68 #include "objdump.h" 69 70 #ifdef HAVE_MMAP 71 #include <sys/mman.h> 72 #endif 73 74 /* Internal headers for the ELF .stab-dump code - sorry. */ 75 #define BYTES_IN_WORD 32 76 #include "aout/aout64.h" 77 78 /* Exit status. */ 79 static int exit_status = 0; 80 81 static char *default_target = NULL; /* Default at runtime. */ 82 83 /* The following variables are set based on arguments passed on the 84 command line. */ 85 static int show_version = 0; /* Show the version number. */ 86 static int dump_section_contents; /* -s */ 87 static int dump_section_headers; /* -h */ 88 static bfd_boolean dump_file_header; /* -f */ 89 static int dump_symtab; /* -t */ 90 static int dump_dynamic_symtab; /* -T */ 91 static int dump_reloc_info; /* -r */ 92 static int dump_dynamic_reloc_info; /* -R */ 93 static int dump_ar_hdrs; /* -a */ 94 static int dump_private_headers; /* -p */ 95 static char *dump_private_options; /* -P */ 96 static int prefix_addresses; /* --prefix-addresses */ 97 static int with_line_numbers; /* -l */ 98 static bfd_boolean with_source_code; /* -S */ 99 static int show_raw_insn; /* --show-raw-insn */ 100 static int dump_dwarf_section_info; /* --dwarf */ 101 static int dump_stab_section_info; /* --stabs */ 102 static int do_demangle; /* -C, --demangle */ 103 static bfd_boolean disassemble; /* -d */ 104 static bfd_boolean disassemble_all; /* -D */ 105 static int disassemble_zeroes; /* --disassemble-zeroes */ 106 static bfd_boolean formats_info; /* -i */ 107 static int wide_output; /* -w */ 108 static int insn_width; /* --insn-width */ 109 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */ 110 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */ 111 static int dump_debugging; /* --debugging */ 112 static int dump_debugging_tags; /* --debugging-tags */ 113 static int suppress_bfd_header; 114 static int dump_special_syms = 0; /* --special-syms */ 115 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */ 116 static int file_start_context = 0; /* --file-start-context */ 117 static bfd_boolean display_file_offsets;/* -F */ 118 static const char *prefix; /* --prefix */ 119 static int prefix_strip; /* --prefix-strip */ 120 static size_t prefix_length; 121 122 /* A structure to record the sections mentioned in -j switches. */ 123 struct only 124 { 125 const char * name; /* The name of the section. */ 126 bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */ 127 struct only * next; /* Pointer to the next structure in the list. */ 128 }; 129 /* Pointer to an array of 'only' structures. 130 This pointer is NULL if the -j switch has not been used. */ 131 static struct only * only_list = NULL; 132 133 /* Variables for handling include file path table. */ 134 static const char **include_paths; 135 static int include_path_count; 136 137 /* Extra info to pass to the section disassembler and address printing 138 function. */ 139 struct objdump_disasm_info 140 { 141 bfd * abfd; 142 asection * sec; 143 bfd_boolean require_sec; 144 arelent ** dynrelbuf; 145 long dynrelcount; 146 disassembler_ftype disassemble_fn; 147 arelent * reloc; 148 }; 149 150 /* Architecture to disassemble for, or default if NULL. */ 151 static char *machine = NULL; 152 153 /* Target specific options to the disassembler. */ 154 static char *disassembler_options = NULL; 155 156 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */ 157 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN; 158 159 /* The symbol table. */ 160 static asymbol **syms; 161 162 /* Number of symbols in `syms'. */ 163 static long symcount = 0; 164 165 /* The sorted symbol table. */ 166 static asymbol **sorted_syms; 167 168 /* Number of symbols in `sorted_syms'. */ 169 static long sorted_symcount = 0; 170 171 /* The dynamic symbol table. */ 172 static asymbol **dynsyms; 173 174 /* The synthetic symbol table. */ 175 static asymbol *synthsyms; 176 static long synthcount = 0; 177 178 /* Number of symbols in `dynsyms'. */ 179 static long dynsymcount = 0; 180 181 static bfd_byte *stabs; 182 static bfd_size_type stab_size; 183 184 static char *strtab; 185 static bfd_size_type stabstr_size; 186 187 static bfd_boolean is_relocatable = FALSE; 188 189 /* Handlers for -P/--private. */ 190 static const struct objdump_private_desc * const objdump_private_vectors[] = 191 { 192 OBJDUMP_PRIVATE_VECTORS 193 NULL 194 }; 195 196 static void 197 usage (FILE *stream, int status) 198 { 199 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name); 200 fprintf (stream, _(" Display information from object <file(s)>.\n")); 201 fprintf (stream, _(" At least one of the following switches must be given:\n")); 202 fprintf (stream, _("\ 203 -a, --archive-headers Display archive header information\n\ 204 -f, --file-headers Display the contents of the overall file header\n\ 205 -p, --private-headers Display object format specific file header contents\n\ 206 -P, --private=OPT,OPT... Display object format specific contents\n\ 207 -h, --[section-]headers Display the contents of the section headers\n\ 208 -x, --all-headers Display the contents of all headers\n\ 209 -d, --disassemble Display assembler contents of executable sections\n\ 210 -D, --disassemble-all Display assembler contents of all sections\n\ 211 -S, --source Intermix source code with disassembly\n\ 212 -s, --full-contents Display the full contents of all sections requested\n\ 213 -g, --debugging Display debug information in object file\n\ 214 -e, --debugging-tags Display debug information using ctags style\n\ 215 -G, --stabs Display (in raw form) any STABS info in the file\n\ 216 -W[lLiaprmfFsoRt] or\n\ 217 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\ 218 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\ 219 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\ 220 Display DWARF info in the file\n\ 221 -t, --syms Display the contents of the symbol table(s)\n\ 222 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\ 223 -r, --reloc Display the relocation entries in the file\n\ 224 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\ 225 @<file> Read options from <file>\n\ 226 -v, --version Display this program's version number\n\ 227 -i, --info List object formats and architectures supported\n\ 228 -H, --help Display this information\n\ 229 ")); 230 if (status != 2) 231 { 232 const struct objdump_private_desc * const *desc; 233 234 fprintf (stream, _("\n The following switches are optional:\n")); 235 fprintf (stream, _("\ 236 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\ 237 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\ 238 -j, --section=NAME Only display information for section NAME\n\ 239 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\ 240 -EB --endian=big Assume big endian format when disassembling\n\ 241 -EL --endian=little Assume little endian format when disassembling\n\ 242 --file-start-context Include context from start of file (with -S)\n\ 243 -I, --include=DIR Add DIR to search list for source files\n\ 244 -l, --line-numbers Include line numbers and filenames in output\n\ 245 -F, --file-offsets Include file offsets when displaying information\n\ 246 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\ 247 The STYLE, if specified, can be `auto', `gnu',\n\ 248 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\ 249 or `gnat'\n\ 250 -w, --wide Format output for more than 80 columns\n\ 251 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\ 252 --start-address=ADDR Only process data whose address is >= ADDR\n\ 253 --stop-address=ADDR Only process data whose address is <= ADDR\n\ 254 --prefix-addresses Print complete address alongside disassembly\n\ 255 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\ 256 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\ 257 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\ 258 --special-syms Include special symbols in symbol dumps\n\ 259 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\ 260 --prefix-strip=LEVEL Strip initial directory names for -S\n")); 261 fprintf (stream, _("\ 262 --dwarf-depth=N Do not display DIEs at depth N or greater\n\ 263 --dwarf-start=N Display DIEs starting with N, at the same depth\n\ 264 or deeper\n\ 265 --dwarf-check Make additional dwarf internal consistency checks.\ 266 \n\n")); 267 list_supported_targets (program_name, stream); 268 list_supported_architectures (program_name, stream); 269 270 disassembler_usage (stream); 271 272 if (objdump_private_vectors[0] != NULL) 273 { 274 fprintf (stream, 275 _("\nOptions supported for -P/--private switch:\n")); 276 for (desc = objdump_private_vectors; *desc != NULL; desc++) 277 (*desc)->help (stream); 278 } 279 } 280 if (REPORT_BUGS_TO[0] && status == 0) 281 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO); 282 exit (status); 283 } 284 285 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */ 286 enum option_values 287 { 288 OPTION_ENDIAN=150, 289 OPTION_START_ADDRESS, 290 OPTION_STOP_ADDRESS, 291 OPTION_DWARF, 292 OPTION_PREFIX, 293 OPTION_PREFIX_STRIP, 294 OPTION_INSN_WIDTH, 295 OPTION_ADJUST_VMA, 296 OPTION_DWARF_DEPTH, 297 OPTION_DWARF_CHECK, 298 OPTION_DWARF_START 299 }; 300 301 static struct option long_options[]= 302 { 303 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA}, 304 {"all-headers", no_argument, NULL, 'x'}, 305 {"private-headers", no_argument, NULL, 'p'}, 306 {"private", required_argument, NULL, 'P'}, 307 {"architecture", required_argument, NULL, 'm'}, 308 {"archive-headers", no_argument, NULL, 'a'}, 309 {"debugging", no_argument, NULL, 'g'}, 310 {"debugging-tags", no_argument, NULL, 'e'}, 311 {"demangle", optional_argument, NULL, 'C'}, 312 {"disassemble", no_argument, NULL, 'd'}, 313 {"disassemble-all", no_argument, NULL, 'D'}, 314 {"disassembler-options", required_argument, NULL, 'M'}, 315 {"disassemble-zeroes", no_argument, NULL, 'z'}, 316 {"dynamic-reloc", no_argument, NULL, 'R'}, 317 {"dynamic-syms", no_argument, NULL, 'T'}, 318 {"endian", required_argument, NULL, OPTION_ENDIAN}, 319 {"file-headers", no_argument, NULL, 'f'}, 320 {"file-offsets", no_argument, NULL, 'F'}, 321 {"file-start-context", no_argument, &file_start_context, 1}, 322 {"full-contents", no_argument, NULL, 's'}, 323 {"headers", no_argument, NULL, 'h'}, 324 {"help", no_argument, NULL, 'H'}, 325 {"info", no_argument, NULL, 'i'}, 326 {"line-numbers", no_argument, NULL, 'l'}, 327 {"no-show-raw-insn", no_argument, &show_raw_insn, -1}, 328 {"prefix-addresses", no_argument, &prefix_addresses, 1}, 329 {"reloc", no_argument, NULL, 'r'}, 330 {"section", required_argument, NULL, 'j'}, 331 {"section-headers", no_argument, NULL, 'h'}, 332 {"show-raw-insn", no_argument, &show_raw_insn, 1}, 333 {"source", no_argument, NULL, 'S'}, 334 {"special-syms", no_argument, &dump_special_syms, 1}, 335 {"include", required_argument, NULL, 'I'}, 336 {"dwarf", optional_argument, NULL, OPTION_DWARF}, 337 {"stabs", no_argument, NULL, 'G'}, 338 {"start-address", required_argument, NULL, OPTION_START_ADDRESS}, 339 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS}, 340 {"syms", no_argument, NULL, 't'}, 341 {"target", required_argument, NULL, 'b'}, 342 {"version", no_argument, NULL, 'V'}, 343 {"wide", no_argument, NULL, 'w'}, 344 {"prefix", required_argument, NULL, OPTION_PREFIX}, 345 {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP}, 346 {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH}, 347 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH}, 348 {"dwarf-start", required_argument, 0, OPTION_DWARF_START}, 349 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK}, 350 {0, no_argument, 0, 0} 351 }; 352 353 static void 354 nonfatal (const char *msg) 355 { 356 bfd_nonfatal (msg); 357 exit_status = 1; 358 } 359 360 /* Returns TRUE if the specified section should be dumped. */ 361 362 static bfd_boolean 363 process_section_p (asection * section) 364 { 365 struct only * only; 366 367 if (only_list == NULL) 368 return TRUE; 369 370 for (only = only_list; only; only = only->next) 371 if (strcmp (only->name, section->name) == 0) 372 { 373 only->seen = TRUE; 374 return TRUE; 375 } 376 377 return FALSE; 378 } 379 380 /* Add an entry to the 'only' list. */ 381 382 static void 383 add_only (char * name) 384 { 385 struct only * only; 386 387 /* First check to make sure that we do not 388 already have an entry for this name. */ 389 for (only = only_list; only; only = only->next) 390 if (strcmp (only->name, name) == 0) 391 return; 392 393 only = xmalloc (sizeof * only); 394 only->name = name; 395 only->seen = FALSE; 396 only->next = only_list; 397 only_list = only; 398 } 399 400 /* Release the memory used by the 'only' list. 401 PR 11225: Issue a warning message for unseen sections. 402 Only do this if none of the sections were seen. This is mainly to support 403 tools like the GAS testsuite where an object file is dumped with a list of 404 generic section names known to be present in a range of different file 405 formats. */ 406 407 static void 408 free_only_list (void) 409 { 410 bfd_boolean at_least_one_seen = FALSE; 411 struct only * only; 412 struct only * next; 413 414 if (only_list == NULL) 415 return; 416 417 for (only = only_list; only; only = only->next) 418 if (only->seen) 419 { 420 at_least_one_seen = TRUE; 421 break; 422 } 423 424 for (only = only_list; only; only = next) 425 { 426 if (! at_least_one_seen) 427 { 428 non_fatal (_("section '%s' mentioned in a -j option, " 429 "but not found in any input file"), 430 only->name); 431 exit_status = 1; 432 } 433 next = only->next; 434 free (only); 435 } 436 } 437 438 439 static void 440 dump_section_header (bfd *abfd, asection *section, 441 void *ignored ATTRIBUTE_UNUSED) 442 { 443 char *comma = ""; 444 unsigned int opb = bfd_octets_per_byte (abfd); 445 446 /* Ignore linker created section. See elfNN_ia64_object_p in 447 bfd/elfxx-ia64.c. */ 448 if (section->flags & SEC_LINKER_CREATED) 449 return; 450 451 /* PR 10413: Skip sections that we are ignoring. */ 452 if (! process_section_p (section)) 453 return; 454 455 printf ("%3d %-13s %08lx ", section->index, 456 bfd_get_section_name (abfd, section), 457 (unsigned long) bfd_section_size (abfd, section) / opb); 458 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section)); 459 printf (" "); 460 bfd_printf_vma (abfd, section->lma); 461 printf (" %08lx 2**%u", (unsigned long) section->filepos, 462 bfd_get_section_alignment (abfd, section)); 463 if (! wide_output) 464 printf ("\n "); 465 printf (" "); 466 467 #define PF(x, y) \ 468 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; } 469 470 PF (SEC_HAS_CONTENTS, "CONTENTS"); 471 PF (SEC_ALLOC, "ALLOC"); 472 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR"); 473 PF (SEC_LOAD, "LOAD"); 474 PF (SEC_RELOC, "RELOC"); 475 PF (SEC_READONLY, "READONLY"); 476 PF (SEC_CODE, "CODE"); 477 PF (SEC_DATA, "DATA"); 478 PF (SEC_ROM, "ROM"); 479 PF (SEC_DEBUGGING, "DEBUGGING"); 480 PF (SEC_NEVER_LOAD, "NEVER_LOAD"); 481 PF (SEC_EXCLUDE, "EXCLUDE"); 482 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES"); 483 if (bfd_get_arch (abfd) == bfd_arch_tic54x) 484 { 485 PF (SEC_TIC54X_BLOCK, "BLOCK"); 486 PF (SEC_TIC54X_CLINK, "CLINK"); 487 } 488 PF (SEC_SMALL_DATA, "SMALL_DATA"); 489 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour) 490 PF (SEC_COFF_SHARED, "SHARED"); 491 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL"); 492 PF (SEC_GROUP, "GROUP"); 493 494 if ((section->flags & SEC_LINK_ONCE) != 0) 495 { 496 const char *ls; 497 struct coff_comdat_info *comdat; 498 499 switch (section->flags & SEC_LINK_DUPLICATES) 500 { 501 default: 502 abort (); 503 case SEC_LINK_DUPLICATES_DISCARD: 504 ls = "LINK_ONCE_DISCARD"; 505 break; 506 case SEC_LINK_DUPLICATES_ONE_ONLY: 507 ls = "LINK_ONCE_ONE_ONLY"; 508 break; 509 case SEC_LINK_DUPLICATES_SAME_SIZE: 510 ls = "LINK_ONCE_SAME_SIZE"; 511 break; 512 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 513 ls = "LINK_ONCE_SAME_CONTENTS"; 514 break; 515 } 516 printf ("%s%s", comma, ls); 517 518 comdat = bfd_coff_get_comdat_section (abfd, section); 519 if (comdat != NULL) 520 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol); 521 522 comma = ", "; 523 } 524 525 printf ("\n"); 526 #undef PF 527 } 528 529 static void 530 dump_headers (bfd *abfd) 531 { 532 printf (_("Sections:\n")); 533 534 #ifndef BFD64 535 printf (_("Idx Name Size VMA LMA File off Algn")); 536 #else 537 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */ 538 if (bfd_get_arch_size (abfd) == 32) 539 printf (_("Idx Name Size VMA LMA File off Algn")); 540 else 541 printf (_("Idx Name Size VMA LMA File off Algn")); 542 #endif 543 544 if (wide_output) 545 printf (_(" Flags")); 546 printf ("\n"); 547 548 bfd_map_over_sections (abfd, dump_section_header, NULL); 549 } 550 551 static asymbol ** 552 slurp_symtab (bfd *abfd) 553 { 554 asymbol **sy = NULL; 555 long storage; 556 557 if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) 558 { 559 symcount = 0; 560 return NULL; 561 } 562 563 storage = bfd_get_symtab_upper_bound (abfd); 564 if (storage < 0) 565 bfd_fatal (bfd_get_filename (abfd)); 566 if (storage) 567 sy = (asymbol **) xmalloc (storage); 568 569 symcount = bfd_canonicalize_symtab (abfd, sy); 570 if (symcount < 0) 571 bfd_fatal (bfd_get_filename (abfd)); 572 return sy; 573 } 574 575 /* Read in the dynamic symbols. */ 576 577 static asymbol ** 578 slurp_dynamic_symtab (bfd *abfd) 579 { 580 asymbol **sy = NULL; 581 long storage; 582 583 storage = bfd_get_dynamic_symtab_upper_bound (abfd); 584 if (storage < 0) 585 { 586 if (!(bfd_get_file_flags (abfd) & DYNAMIC)) 587 { 588 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd)); 589 exit_status = 1; 590 dynsymcount = 0; 591 return NULL; 592 } 593 594 bfd_fatal (bfd_get_filename (abfd)); 595 } 596 if (storage) 597 sy = (asymbol **) xmalloc (storage); 598 599 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy); 600 if (dynsymcount < 0) 601 bfd_fatal (bfd_get_filename (abfd)); 602 return sy; 603 } 604 605 /* Filter out (in place) symbols that are useless for disassembly. 606 COUNT is the number of elements in SYMBOLS. 607 Return the number of useful symbols. */ 608 609 static long 610 remove_useless_symbols (asymbol **symbols, long count) 611 { 612 asymbol **in_ptr = symbols, **out_ptr = symbols; 613 614 while (--count >= 0) 615 { 616 asymbol *sym = *in_ptr++; 617 618 if (sym->name == NULL || sym->name[0] == '\0') 619 continue; 620 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM)) 621 continue; 622 if (bfd_is_und_section (sym->section) 623 || bfd_is_com_section (sym->section)) 624 continue; 625 626 *out_ptr++ = sym; 627 } 628 return out_ptr - symbols; 629 } 630 631 /* Sort symbols into value order. */ 632 633 static int 634 compare_symbols (const void *ap, const void *bp) 635 { 636 const asymbol *a = * (const asymbol **) ap; 637 const asymbol *b = * (const asymbol **) bp; 638 const char *an; 639 const char *bn; 640 size_t anl; 641 size_t bnl; 642 bfd_boolean af; 643 bfd_boolean bf; 644 flagword aflags; 645 flagword bflags; 646 647 if (bfd_asymbol_value (a) > bfd_asymbol_value (b)) 648 return 1; 649 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b)) 650 return -1; 651 652 if (a->section > b->section) 653 return 1; 654 else if (a->section < b->section) 655 return -1; 656 657 an = bfd_asymbol_name (a); 658 bn = bfd_asymbol_name (b); 659 anl = strlen (an); 660 bnl = strlen (bn); 661 662 /* The symbols gnu_compiled and gcc2_compiled convey no real 663 information, so put them after other symbols with the same value. */ 664 af = (strstr (an, "gnu_compiled") != NULL 665 || strstr (an, "gcc2_compiled") != NULL); 666 bf = (strstr (bn, "gnu_compiled") != NULL 667 || strstr (bn, "gcc2_compiled") != NULL); 668 669 if (af && ! bf) 670 return 1; 671 if (! af && bf) 672 return -1; 673 674 /* We use a heuristic for the file name, to try to sort it after 675 more useful symbols. It may not work on non Unix systems, but it 676 doesn't really matter; the only difference is precisely which 677 symbol names get printed. */ 678 679 #define file_symbol(s, sn, snl) \ 680 (((s)->flags & BSF_FILE) != 0 \ 681 || ((sn)[(snl) - 2] == '.' \ 682 && ((sn)[(snl) - 1] == 'o' \ 683 || (sn)[(snl) - 1] == 'a'))) 684 685 af = file_symbol (a, an, anl); 686 bf = file_symbol (b, bn, bnl); 687 688 if (af && ! bf) 689 return 1; 690 if (! af && bf) 691 return -1; 692 693 /* Try to sort global symbols before local symbols before function 694 symbols before debugging symbols. */ 695 696 aflags = a->flags; 697 bflags = b->flags; 698 699 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING)) 700 { 701 if ((aflags & BSF_DEBUGGING) != 0) 702 return 1; 703 else 704 return -1; 705 } 706 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION)) 707 { 708 if ((aflags & BSF_FUNCTION) != 0) 709 return -1; 710 else 711 return 1; 712 } 713 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL)) 714 { 715 if ((aflags & BSF_LOCAL) != 0) 716 return 1; 717 else 718 return -1; 719 } 720 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL)) 721 { 722 if ((aflags & BSF_GLOBAL) != 0) 723 return -1; 724 else 725 return 1; 726 } 727 728 /* Symbols that start with '.' might be section names, so sort them 729 after symbols that don't start with '.'. */ 730 if (an[0] == '.' && bn[0] != '.') 731 return 1; 732 if (an[0] != '.' && bn[0] == '.') 733 return -1; 734 735 /* Finally, if we can't distinguish them in any other way, try to 736 get consistent results by sorting the symbols by name. */ 737 return strcmp (an, bn); 738 } 739 740 /* Sort relocs into address order. */ 741 742 static int 743 compare_relocs (const void *ap, const void *bp) 744 { 745 const arelent *a = * (const arelent **) ap; 746 const arelent *b = * (const arelent **) bp; 747 748 if (a->address > b->address) 749 return 1; 750 else if (a->address < b->address) 751 return -1; 752 753 /* So that associated relocations tied to the same address show up 754 in the correct order, we don't do any further sorting. */ 755 if (a > b) 756 return 1; 757 else if (a < b) 758 return -1; 759 else 760 return 0; 761 } 762 763 /* Print an address (VMA) to the output stream in INFO. 764 If SKIP_ZEROES is TRUE, omit leading zeroes. */ 765 766 static void 767 objdump_print_value (bfd_vma vma, struct disassemble_info *inf, 768 bfd_boolean skip_zeroes) 769 { 770 char buf[30]; 771 char *p; 772 struct objdump_disasm_info *aux; 773 774 aux = (struct objdump_disasm_info *) inf->application_data; 775 bfd_sprintf_vma (aux->abfd, buf, vma); 776 if (! skip_zeroes) 777 p = buf; 778 else 779 { 780 for (p = buf; *p == '0'; ++p) 781 ; 782 if (*p == '\0') 783 --p; 784 } 785 (*inf->fprintf_func) (inf->stream, "%s", p); 786 } 787 788 /* Print the name of a symbol. */ 789 790 static void 791 objdump_print_symname (bfd *abfd, struct disassemble_info *inf, 792 asymbol *sym) 793 { 794 char *alloc; 795 const char *name; 796 797 alloc = NULL; 798 name = bfd_asymbol_name (sym); 799 if (do_demangle && name[0] != '\0') 800 { 801 /* Demangle the name. */ 802 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS); 803 if (alloc != NULL) 804 name = alloc; 805 } 806 807 if (inf != NULL) 808 (*inf->fprintf_func) (inf->stream, "%s", name); 809 else 810 printf ("%s", name); 811 812 if (alloc != NULL) 813 free (alloc); 814 } 815 816 /* Locate a symbol given a bfd and a section (from INFO->application_data), 817 and a VMA. If INFO->application_data->require_sec is TRUE, then always 818 require the symbol to be in the section. Returns NULL if there is no 819 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index 820 of the symbol in sorted_syms. */ 821 822 static asymbol * 823 find_symbol_for_address (bfd_vma vma, 824 struct disassemble_info *inf, 825 long *place) 826 { 827 /* @@ Would it speed things up to cache the last two symbols returned, 828 and maybe their address ranges? For many processors, only one memory 829 operand can be present at a time, so the 2-entry cache wouldn't be 830 constantly churned by code doing heavy memory accesses. */ 831 832 /* Indices in `sorted_syms'. */ 833 long min = 0; 834 long max_count = sorted_symcount; 835 long thisplace; 836 struct objdump_disasm_info *aux; 837 bfd *abfd; 838 asection *sec; 839 unsigned int opb; 840 bfd_boolean want_section; 841 842 if (sorted_symcount < 1) 843 return NULL; 844 845 aux = (struct objdump_disasm_info *) inf->application_data; 846 abfd = aux->abfd; 847 sec = aux->sec; 848 opb = inf->octets_per_byte; 849 850 /* Perform a binary search looking for the closest symbol to the 851 required value. We are searching the range (min, max_count]. */ 852 while (min + 1 < max_count) 853 { 854 asymbol *sym; 855 856 thisplace = (max_count + min) / 2; 857 sym = sorted_syms[thisplace]; 858 859 if (bfd_asymbol_value (sym) > vma) 860 max_count = thisplace; 861 else if (bfd_asymbol_value (sym) < vma) 862 min = thisplace; 863 else 864 { 865 min = thisplace; 866 break; 867 } 868 } 869 870 /* The symbol we want is now in min, the low end of the range we 871 were searching. If there are several symbols with the same 872 value, we want the first one. */ 873 thisplace = min; 874 while (thisplace > 0 875 && (bfd_asymbol_value (sorted_syms[thisplace]) 876 == bfd_asymbol_value (sorted_syms[thisplace - 1]))) 877 --thisplace; 878 879 /* Prefer a symbol in the current section if we have multple symbols 880 with the same value, as can occur with overlays or zero size 881 sections. */ 882 min = thisplace; 883 while (min < max_count 884 && (bfd_asymbol_value (sorted_syms[min]) 885 == bfd_asymbol_value (sorted_syms[thisplace]))) 886 { 887 if (sorted_syms[min]->section == sec 888 && inf->symbol_is_valid (sorted_syms[min], inf)) 889 { 890 thisplace = min; 891 892 if (place != NULL) 893 *place = thisplace; 894 895 return sorted_syms[thisplace]; 896 } 897 ++min; 898 } 899 900 /* If the file is relocatable, and the symbol could be from this 901 section, prefer a symbol from this section over symbols from 902 others, even if the other symbol's value might be closer. 903 904 Note that this may be wrong for some symbol references if the 905 sections have overlapping memory ranges, but in that case there's 906 no way to tell what's desired without looking at the relocation 907 table. 908 909 Also give the target a chance to reject symbols. */ 910 want_section = (aux->require_sec 911 || ((abfd->flags & HAS_RELOC) != 0 912 && vma >= bfd_get_section_vma (abfd, sec) 913 && vma < (bfd_get_section_vma (abfd, sec) 914 + bfd_section_size (abfd, sec) / opb))); 915 if ((sorted_syms[thisplace]->section != sec && want_section) 916 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf)) 917 { 918 long i; 919 long newplace = sorted_symcount; 920 921 for (i = min - 1; i >= 0; i--) 922 { 923 if ((sorted_syms[i]->section == sec || !want_section) 924 && inf->symbol_is_valid (sorted_syms[i], inf)) 925 { 926 if (newplace == sorted_symcount) 927 newplace = i; 928 929 if (bfd_asymbol_value (sorted_syms[i]) 930 != bfd_asymbol_value (sorted_syms[newplace])) 931 break; 932 933 /* Remember this symbol and keep searching until we reach 934 an earlier address. */ 935 newplace = i; 936 } 937 } 938 939 if (newplace != sorted_symcount) 940 thisplace = newplace; 941 else 942 { 943 /* We didn't find a good symbol with a smaller value. 944 Look for one with a larger value. */ 945 for (i = thisplace + 1; i < sorted_symcount; i++) 946 { 947 if ((sorted_syms[i]->section == sec || !want_section) 948 && inf->symbol_is_valid (sorted_syms[i], inf)) 949 { 950 thisplace = i; 951 break; 952 } 953 } 954 } 955 956 if ((sorted_syms[thisplace]->section != sec && want_section) 957 || ! inf->symbol_is_valid (sorted_syms[thisplace], inf)) 958 /* There is no suitable symbol. */ 959 return NULL; 960 } 961 962 if (place != NULL) 963 *place = thisplace; 964 965 return sorted_syms[thisplace]; 966 } 967 968 /* Print an address and the offset to the nearest symbol. */ 969 970 static void 971 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym, 972 bfd_vma vma, struct disassemble_info *inf, 973 bfd_boolean skip_zeroes) 974 { 975 objdump_print_value (vma, inf, skip_zeroes); 976 977 if (sym == NULL) 978 { 979 bfd_vma secaddr; 980 981 (*inf->fprintf_func) (inf->stream, " <%s", 982 bfd_get_section_name (abfd, sec)); 983 secaddr = bfd_get_section_vma (abfd, sec); 984 if (vma < secaddr) 985 { 986 (*inf->fprintf_func) (inf->stream, "-0x"); 987 objdump_print_value (secaddr - vma, inf, TRUE); 988 } 989 else if (vma > secaddr) 990 { 991 (*inf->fprintf_func) (inf->stream, "+0x"); 992 objdump_print_value (vma - secaddr, inf, TRUE); 993 } 994 (*inf->fprintf_func) (inf->stream, ">"); 995 } 996 else 997 { 998 (*inf->fprintf_func) (inf->stream, " <"); 999 objdump_print_symname (abfd, inf, sym); 1000 if (bfd_asymbol_value (sym) > vma) 1001 { 1002 (*inf->fprintf_func) (inf->stream, "-0x"); 1003 objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE); 1004 } 1005 else if (vma > bfd_asymbol_value (sym)) 1006 { 1007 (*inf->fprintf_func) (inf->stream, "+0x"); 1008 objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE); 1009 } 1010 (*inf->fprintf_func) (inf->stream, ">"); 1011 } 1012 1013 if (display_file_offsets) 1014 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"), 1015 (long int)(sec->filepos + (vma - sec->vma))); 1016 } 1017 1018 /* Print an address (VMA), symbolically if possible. 1019 If SKIP_ZEROES is TRUE, don't output leading zeroes. */ 1020 1021 static void 1022 objdump_print_addr (bfd_vma vma, 1023 struct disassemble_info *inf, 1024 bfd_boolean skip_zeroes) 1025 { 1026 struct objdump_disasm_info *aux; 1027 asymbol *sym = NULL; 1028 bfd_boolean skip_find = FALSE; 1029 1030 aux = (struct objdump_disasm_info *) inf->application_data; 1031 1032 if (sorted_symcount < 1) 1033 { 1034 (*inf->fprintf_func) (inf->stream, "0x"); 1035 objdump_print_value (vma, inf, skip_zeroes); 1036 1037 if (display_file_offsets) 1038 inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"), 1039 (long int)(aux->sec->filepos + (vma - aux->sec->vma))); 1040 return; 1041 } 1042 1043 if (aux->reloc != NULL 1044 && aux->reloc->sym_ptr_ptr != NULL 1045 && * aux->reloc->sym_ptr_ptr != NULL) 1046 { 1047 sym = * aux->reloc->sym_ptr_ptr; 1048 1049 /* Adjust the vma to the reloc. */ 1050 vma += bfd_asymbol_value (sym); 1051 1052 if (bfd_is_und_section (bfd_get_section (sym))) 1053 skip_find = TRUE; 1054 } 1055 1056 if (!skip_find) 1057 sym = find_symbol_for_address (vma, inf, NULL); 1058 1059 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf, 1060 skip_zeroes); 1061 } 1062 1063 /* Print VMA to INFO. This function is passed to the disassembler 1064 routine. */ 1065 1066 static void 1067 objdump_print_address (bfd_vma vma, struct disassemble_info *inf) 1068 { 1069 objdump_print_addr (vma, inf, ! prefix_addresses); 1070 } 1071 1072 /* Determine if the given address has a symbol associated with it. */ 1073 1074 static int 1075 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf) 1076 { 1077 asymbol * sym; 1078 1079 sym = find_symbol_for_address (vma, inf, NULL); 1080 1081 return (sym != NULL && (bfd_asymbol_value (sym) == vma)); 1082 } 1083 1084 /* Hold the last function name and the last line number we displayed 1085 in a disassembly. */ 1086 1087 static char *prev_functionname; 1088 static unsigned int prev_line; 1089 static unsigned int prev_discriminator; 1090 1091 /* We keep a list of all files that we have seen when doing a 1092 disassembly with source, so that we know how much of the file to 1093 display. This can be important for inlined functions. */ 1094 1095 struct print_file_list 1096 { 1097 struct print_file_list *next; 1098 const char *filename; 1099 const char *modname; 1100 const char *map; 1101 size_t mapsize; 1102 const char **linemap; 1103 unsigned maxline; 1104 unsigned last_line; 1105 int first; 1106 }; 1107 1108 static struct print_file_list *print_files; 1109 1110 /* The number of preceding context lines to show when we start 1111 displaying a file for the first time. */ 1112 1113 #define SHOW_PRECEDING_CONTEXT_LINES (5) 1114 1115 /* Read a complete file into memory. */ 1116 1117 static const char * 1118 slurp_file (const char *fn, size_t *size) 1119 { 1120 #ifdef HAVE_MMAP 1121 int ps = getpagesize (); 1122 size_t msize; 1123 #endif 1124 const char *map; 1125 struct stat st; 1126 int fd = open (fn, O_RDONLY | O_BINARY); 1127 1128 if (fd < 0) 1129 return NULL; 1130 if (fstat (fd, &st) < 0) 1131 { 1132 close (fd); 1133 return NULL; 1134 } 1135 *size = st.st_size; 1136 #ifdef HAVE_MMAP 1137 msize = (*size + ps - 1) & ~(ps - 1); 1138 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0); 1139 if (map != (char *) -1L) 1140 { 1141 close (fd); 1142 return map; 1143 } 1144 #endif 1145 map = (const char *) malloc (*size); 1146 if (!map || (size_t) read (fd, (char *) map, *size) != *size) 1147 { 1148 free ((void *) map); 1149 map = NULL; 1150 } 1151 close (fd); 1152 return map; 1153 } 1154 1155 #define line_map_decrease 5 1156 1157 /* Precompute array of lines for a mapped file. */ 1158 1159 static const char ** 1160 index_file (const char *map, size_t size, unsigned int *maxline) 1161 { 1162 const char *p, *lstart, *end; 1163 int chars_per_line = 45; /* First iteration will use 40. */ 1164 unsigned int lineno; 1165 const char **linemap = NULL; 1166 unsigned long line_map_size = 0; 1167 1168 lineno = 0; 1169 lstart = map; 1170 end = map + size; 1171 1172 for (p = map; p < end; p++) 1173 { 1174 if (*p == '\n') 1175 { 1176 if (p + 1 < end && p[1] == '\r') 1177 p++; 1178 } 1179 else if (*p == '\r') 1180 { 1181 if (p + 1 < end && p[1] == '\n') 1182 p++; 1183 } 1184 else 1185 continue; 1186 1187 /* End of line found. */ 1188 1189 if (linemap == NULL || line_map_size < lineno + 1) 1190 { 1191 unsigned long newsize; 1192 1193 chars_per_line -= line_map_decrease; 1194 if (chars_per_line <= 1) 1195 chars_per_line = 1; 1196 line_map_size = size / chars_per_line + 1; 1197 if (line_map_size < lineno + 1) 1198 line_map_size = lineno + 1; 1199 newsize = line_map_size * sizeof (char *); 1200 linemap = (const char **) xrealloc (linemap, newsize); 1201 } 1202 1203 linemap[lineno++] = lstart; 1204 lstart = p + 1; 1205 } 1206 1207 *maxline = lineno; 1208 return linemap; 1209 } 1210 1211 /* Tries to open MODNAME, and if successful adds a node to print_files 1212 linked list and returns that node. Returns NULL on failure. */ 1213 1214 static struct print_file_list * 1215 try_print_file_open (const char *origname, const char *modname) 1216 { 1217 struct print_file_list *p; 1218 1219 p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list)); 1220 1221 p->map = slurp_file (modname, &p->mapsize); 1222 if (p->map == NULL) 1223 { 1224 free (p); 1225 return NULL; 1226 } 1227 1228 p->linemap = index_file (p->map, p->mapsize, &p->maxline); 1229 p->last_line = 0; 1230 p->filename = origname; 1231 p->modname = modname; 1232 p->next = print_files; 1233 p->first = 1; 1234 print_files = p; 1235 return p; 1236 } 1237 1238 /* If the the source file, as described in the symtab, is not found 1239 try to locate it in one of the paths specified with -I 1240 If found, add location to print_files linked list. */ 1241 1242 static struct print_file_list * 1243 update_source_path (const char *filename) 1244 { 1245 struct print_file_list *p; 1246 const char *fname; 1247 int i; 1248 1249 p = try_print_file_open (filename, filename); 1250 if (p != NULL) 1251 return p; 1252 1253 if (include_path_count == 0) 1254 return NULL; 1255 1256 /* Get the name of the file. */ 1257 fname = lbasename (filename); 1258 1259 /* If file exists under a new path, we need to add it to the list 1260 so that show_line knows about it. */ 1261 for (i = 0; i < include_path_count; i++) 1262 { 1263 char *modname = concat (include_paths[i], "/", fname, (const char *) 0); 1264 1265 p = try_print_file_open (filename, modname); 1266 if (p) 1267 return p; 1268 1269 free (modname); 1270 } 1271 1272 return NULL; 1273 } 1274 1275 /* Print a source file line. */ 1276 1277 static void 1278 print_line (struct print_file_list *p, unsigned int linenum) 1279 { 1280 const char *l; 1281 size_t len; 1282 1283 --linenum; 1284 if (linenum >= p->maxline) 1285 return; 1286 l = p->linemap [linenum]; 1287 /* Test fwrite return value to quiet glibc warning. */ 1288 len = strcspn (l, "\n\r"); 1289 if (len == 0 || fwrite (l, len, 1, stdout) == 1) 1290 putchar ('\n'); 1291 } 1292 1293 /* Print a range of source code lines. */ 1294 1295 static void 1296 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end) 1297 { 1298 if (p->map == NULL) 1299 return; 1300 while (start <= end) 1301 { 1302 print_line (p, start); 1303 start++; 1304 } 1305 } 1306 1307 /* Show the line number, or the source line, in a disassembly 1308 listing. */ 1309 1310 static void 1311 show_line (bfd *abfd, asection *section, bfd_vma addr_offset) 1312 { 1313 const char *filename; 1314 const char *functionname; 1315 unsigned int linenumber; 1316 unsigned int discriminator; 1317 bfd_boolean reloc; 1318 1319 if (! with_line_numbers && ! with_source_code) 1320 return; 1321 1322 if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset, 1323 &filename, &functionname, 1324 &linenumber, &discriminator)) 1325 return; 1326 1327 if (filename != NULL && *filename == '\0') 1328 filename = NULL; 1329 if (functionname != NULL && *functionname == '\0') 1330 functionname = NULL; 1331 1332 if (filename 1333 && IS_ABSOLUTE_PATH (filename) 1334 && prefix) 1335 { 1336 char *path_up; 1337 const char *fname = filename; 1338 char *path = (char *) alloca (prefix_length + PATH_MAX + 1); 1339 1340 if (prefix_length) 1341 memcpy (path, prefix, prefix_length); 1342 path_up = path + prefix_length; 1343 1344 /* Build relocated filename, stripping off leading directories 1345 from the initial filename if requested. */ 1346 if (prefix_strip > 0) 1347 { 1348 int level = 0; 1349 const char *s; 1350 1351 /* Skip selected directory levels. */ 1352 for (s = fname + 1; *s != '\0' && level < prefix_strip; s++) 1353 if (IS_DIR_SEPARATOR(*s)) 1354 { 1355 fname = s; 1356 level++; 1357 } 1358 } 1359 1360 /* Update complete filename. */ 1361 strncpy (path_up, fname, PATH_MAX); 1362 path_up[PATH_MAX] = '\0'; 1363 1364 filename = path; 1365 reloc = TRUE; 1366 } 1367 else 1368 reloc = FALSE; 1369 1370 if (with_line_numbers) 1371 { 1372 if (functionname != NULL 1373 && (prev_functionname == NULL 1374 || strcmp (functionname, prev_functionname) != 0)) 1375 printf ("%s():\n", functionname); 1376 if (linenumber > 0 && (linenumber != prev_line || 1377 (discriminator != prev_discriminator))) 1378 { 1379 if (discriminator > 0) 1380 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename, 1381 linenumber, discriminator); 1382 else 1383 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber); 1384 } 1385 } 1386 1387 if (with_source_code 1388 && filename != NULL 1389 && linenumber > 0) 1390 { 1391 struct print_file_list **pp, *p; 1392 unsigned l; 1393 1394 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next) 1395 if (filename_cmp ((*pp)->filename, filename) == 0) 1396 break; 1397 p = *pp; 1398 1399 if (p == NULL) 1400 { 1401 if (reloc) 1402 filename = xstrdup (filename); 1403 p = update_source_path (filename); 1404 } 1405 1406 if (p != NULL && linenumber != p->last_line) 1407 { 1408 if (file_start_context && p->first) 1409 l = 1; 1410 else 1411 { 1412 l = linenumber - SHOW_PRECEDING_CONTEXT_LINES; 1413 if (l >= linenumber) 1414 l = 1; 1415 if (p->last_line >= l && p->last_line <= linenumber) 1416 l = p->last_line + 1; 1417 } 1418 dump_lines (p, l, linenumber); 1419 p->last_line = linenumber; 1420 p->first = 0; 1421 } 1422 } 1423 1424 if (functionname != NULL 1425 && (prev_functionname == NULL 1426 || strcmp (functionname, prev_functionname) != 0)) 1427 { 1428 if (prev_functionname != NULL) 1429 free (prev_functionname); 1430 prev_functionname = (char *) xmalloc (strlen (functionname) + 1); 1431 strcpy (prev_functionname, functionname); 1432 } 1433 1434 if (linenumber > 0 && linenumber != prev_line) 1435 prev_line = linenumber; 1436 1437 if (discriminator != prev_discriminator) 1438 prev_discriminator = discriminator; 1439 } 1440 1441 /* Pseudo FILE object for strings. */ 1442 typedef struct 1443 { 1444 char *buffer; 1445 size_t pos; 1446 size_t alloc; 1447 } SFILE; 1448 1449 /* sprintf to a "stream". */ 1450 1451 static int ATTRIBUTE_PRINTF_2 1452 objdump_sprintf (SFILE *f, const char *format, ...) 1453 { 1454 size_t n; 1455 va_list args; 1456 1457 while (1) 1458 { 1459 size_t space = f->alloc - f->pos; 1460 1461 va_start (args, format); 1462 n = vsnprintf (f->buffer + f->pos, space, format, args); 1463 va_end (args); 1464 1465 if (space > n) 1466 break; 1467 1468 f->alloc = (f->alloc + n) * 2; 1469 f->buffer = (char *) xrealloc (f->buffer, f->alloc); 1470 } 1471 f->pos += n; 1472 1473 return n; 1474 } 1475 1476 /* The number of zeroes we want to see before we start skipping them. 1477 The number is arbitrarily chosen. */ 1478 1479 #define DEFAULT_SKIP_ZEROES 8 1480 1481 /* The number of zeroes to skip at the end of a section. If the 1482 number of zeroes at the end is between SKIP_ZEROES_AT_END and 1483 SKIP_ZEROES, they will be disassembled. If there are fewer than 1484 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic 1485 attempt to avoid disassembling zeroes inserted by section 1486 alignment. */ 1487 1488 #define DEFAULT_SKIP_ZEROES_AT_END 3 1489 1490 /* Disassemble some data in memory between given values. */ 1491 1492 static void 1493 disassemble_bytes (struct disassemble_info * inf, 1494 disassembler_ftype disassemble_fn, 1495 bfd_boolean insns, 1496 bfd_byte * data, 1497 bfd_vma start_offset, 1498 bfd_vma stop_offset, 1499 bfd_vma rel_offset, 1500 arelent *** relppp, 1501 arelent ** relppend) 1502 { 1503 struct objdump_disasm_info *aux; 1504 asection *section; 1505 int octets_per_line; 1506 int skip_addr_chars; 1507 bfd_vma addr_offset; 1508 unsigned int opb = inf->octets_per_byte; 1509 unsigned int skip_zeroes = inf->skip_zeroes; 1510 unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end; 1511 int octets = opb; 1512 SFILE sfile; 1513 1514 aux = (struct objdump_disasm_info *) inf->application_data; 1515 section = aux->sec; 1516 1517 sfile.alloc = 120; 1518 sfile.buffer = (char *) xmalloc (sfile.alloc); 1519 sfile.pos = 0; 1520 1521 if (insn_width) 1522 octets_per_line = insn_width; 1523 else if (insns) 1524 octets_per_line = 4; 1525 else 1526 octets_per_line = 16; 1527 1528 /* Figure out how many characters to skip at the start of an 1529 address, to make the disassembly look nicer. We discard leading 1530 zeroes in chunks of 4, ensuring that there is always a leading 1531 zero remaining. */ 1532 skip_addr_chars = 0; 1533 if (! prefix_addresses) 1534 { 1535 char buf[30]; 1536 1537 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb); 1538 1539 while (buf[skip_addr_chars] == '0') 1540 ++skip_addr_chars; 1541 1542 /* Don't discard zeros on overflow. */ 1543 if (buf[skip_addr_chars] == '\0' && section->vma != 0) 1544 skip_addr_chars = 0; 1545 1546 if (skip_addr_chars != 0) 1547 skip_addr_chars = (skip_addr_chars - 1) & -4; 1548 } 1549 1550 inf->insn_info_valid = 0; 1551 1552 addr_offset = start_offset; 1553 while (addr_offset < stop_offset) 1554 { 1555 bfd_vma z; 1556 bfd_boolean need_nl = FALSE; 1557 int previous_octets; 1558 1559 /* Remember the length of the previous instruction. */ 1560 previous_octets = octets; 1561 octets = 0; 1562 1563 /* Make sure we don't use relocs from previous instructions. */ 1564 aux->reloc = NULL; 1565 1566 /* If we see more than SKIP_ZEROES octets of zeroes, we just 1567 print `...'. */ 1568 for (z = addr_offset * opb; z < stop_offset * opb; z++) 1569 if (data[z] != 0) 1570 break; 1571 if (! disassemble_zeroes 1572 && (inf->insn_info_valid == 0 1573 || inf->branch_delay_insns == 0) 1574 && (z - addr_offset * opb >= skip_zeroes 1575 || (z == stop_offset * opb && 1576 z - addr_offset * opb < skip_zeroes_at_end))) 1577 { 1578 /* If there are more nonzero octets to follow, we only skip 1579 zeroes in multiples of 4, to try to avoid running over 1580 the start of an instruction which happens to start with 1581 zero. */ 1582 if (z != stop_offset * opb) 1583 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3); 1584 1585 octets = z - addr_offset * opb; 1586 1587 /* If we are going to display more data, and we are displaying 1588 file offsets, then tell the user how many zeroes we skip 1589 and the file offset from where we resume dumping. */ 1590 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset)) 1591 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n", 1592 octets / opb, 1593 (unsigned long) (section->filepos 1594 + (addr_offset + (octets / opb)))); 1595 else 1596 printf ("\t...\n"); 1597 } 1598 else 1599 { 1600 char buf[50]; 1601 int bpc = 0; 1602 int pb = 0; 1603 1604 if (with_line_numbers || with_source_code) 1605 show_line (aux->abfd, section, addr_offset); 1606 1607 if (! prefix_addresses) 1608 { 1609 char *s; 1610 1611 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset); 1612 for (s = buf + skip_addr_chars; *s == '0'; s++) 1613 *s = ' '; 1614 if (*s == '\0') 1615 *--s = '0'; 1616 printf ("%s:\t", buf + skip_addr_chars); 1617 } 1618 else 1619 { 1620 aux->require_sec = TRUE; 1621 objdump_print_address (section->vma + addr_offset, inf); 1622 aux->require_sec = FALSE; 1623 putchar (' '); 1624 } 1625 1626 if (insns) 1627 { 1628 sfile.pos = 0; 1629 inf->fprintf_func = (fprintf_ftype) objdump_sprintf; 1630 inf->stream = &sfile; 1631 inf->bytes_per_line = 0; 1632 inf->bytes_per_chunk = 0; 1633 inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0; 1634 if (machine) 1635 inf->flags |= USER_SPECIFIED_MACHINE_TYPE; 1636 1637 if (inf->disassembler_needs_relocs 1638 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0 1639 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0 1640 && *relppp < relppend) 1641 { 1642 bfd_signed_vma distance_to_rel; 1643 1644 distance_to_rel = (**relppp)->address 1645 - (rel_offset + addr_offset); 1646 1647 /* Check to see if the current reloc is associated with 1648 the instruction that we are about to disassemble. */ 1649 if (distance_to_rel == 0 1650 /* FIXME: This is wrong. We are trying to catch 1651 relocs that are addressed part way through the 1652 current instruction, as might happen with a packed 1653 VLIW instruction. Unfortunately we do not know the 1654 length of the current instruction since we have not 1655 disassembled it yet. Instead we take a guess based 1656 upon the length of the previous instruction. The 1657 proper solution is to have a new target-specific 1658 disassembler function which just returns the length 1659 of an instruction at a given address without trying 1660 to display its disassembly. */ 1661 || (distance_to_rel > 0 1662 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb))) 1663 { 1664 inf->flags |= INSN_HAS_RELOC; 1665 aux->reloc = **relppp; 1666 } 1667 } 1668 1669 octets = (*disassemble_fn) (section->vma + addr_offset, inf); 1670 inf->fprintf_func = (fprintf_ftype) fprintf; 1671 inf->stream = stdout; 1672 if (insn_width == 0 && inf->bytes_per_line != 0) 1673 octets_per_line = inf->bytes_per_line; 1674 if (octets < (int) opb) 1675 { 1676 if (sfile.pos) 1677 printf ("%s\n", sfile.buffer); 1678 if (octets >= 0) 1679 { 1680 non_fatal (_("disassemble_fn returned length %d"), 1681 octets); 1682 exit_status = 1; 1683 } 1684 break; 1685 } 1686 } 1687 else 1688 { 1689 bfd_vma j; 1690 1691 octets = octets_per_line; 1692 if (addr_offset + octets / opb > stop_offset) 1693 octets = (stop_offset - addr_offset) * opb; 1694 1695 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j) 1696 { 1697 if (ISPRINT (data[j])) 1698 buf[j - addr_offset * opb] = data[j]; 1699 else 1700 buf[j - addr_offset * opb] = '.'; 1701 } 1702 buf[j - addr_offset * opb] = '\0'; 1703 } 1704 1705 if (prefix_addresses 1706 ? show_raw_insn > 0 1707 : show_raw_insn >= 0) 1708 { 1709 bfd_vma j; 1710 1711 /* If ! prefix_addresses and ! wide_output, we print 1712 octets_per_line octets per line. */ 1713 pb = octets; 1714 if (pb > octets_per_line && ! prefix_addresses && ! wide_output) 1715 pb = octets_per_line; 1716 1717 if (inf->bytes_per_chunk) 1718 bpc = inf->bytes_per_chunk; 1719 else 1720 bpc = 1; 1721 1722 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc) 1723 { 1724 int k; 1725 1726 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE) 1727 { 1728 for (k = bpc - 1; k >= 0; k--) 1729 printf ("%02x", (unsigned) data[j + k]); 1730 putchar (' '); 1731 } 1732 else 1733 { 1734 for (k = 0; k < bpc; k++) 1735 printf ("%02x", (unsigned) data[j + k]); 1736 putchar (' '); 1737 } 1738 } 1739 1740 for (; pb < octets_per_line; pb += bpc) 1741 { 1742 int k; 1743 1744 for (k = 0; k < bpc; k++) 1745 printf (" "); 1746 putchar (' '); 1747 } 1748 1749 /* Separate raw data from instruction by extra space. */ 1750 if (insns) 1751 putchar ('\t'); 1752 else 1753 printf (" "); 1754 } 1755 1756 if (! insns) 1757 printf ("%s", buf); 1758 else if (sfile.pos) 1759 printf ("%s", sfile.buffer); 1760 1761 if (prefix_addresses 1762 ? show_raw_insn > 0 1763 : show_raw_insn >= 0) 1764 { 1765 while (pb < octets) 1766 { 1767 bfd_vma j; 1768 char *s; 1769 1770 putchar ('\n'); 1771 j = addr_offset * opb + pb; 1772 1773 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb); 1774 for (s = buf + skip_addr_chars; *s == '0'; s++) 1775 *s = ' '; 1776 if (*s == '\0') 1777 *--s = '0'; 1778 printf ("%s:\t", buf + skip_addr_chars); 1779 1780 pb += octets_per_line; 1781 if (pb > octets) 1782 pb = octets; 1783 for (; j < addr_offset * opb + pb; j += bpc) 1784 { 1785 int k; 1786 1787 if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE) 1788 { 1789 for (k = bpc - 1; k >= 0; k--) 1790 printf ("%02x", (unsigned) data[j + k]); 1791 putchar (' '); 1792 } 1793 else 1794 { 1795 for (k = 0; k < bpc; k++) 1796 printf ("%02x", (unsigned) data[j + k]); 1797 putchar (' '); 1798 } 1799 } 1800 } 1801 } 1802 1803 if (!wide_output) 1804 putchar ('\n'); 1805 else 1806 need_nl = TRUE; 1807 } 1808 1809 while ((*relppp) < relppend 1810 && (**relppp)->address < rel_offset + addr_offset + octets / opb) 1811 { 1812 if (dump_reloc_info || dump_dynamic_reloc_info) 1813 { 1814 arelent *q; 1815 1816 q = **relppp; 1817 1818 if (wide_output) 1819 putchar ('\t'); 1820 else 1821 printf ("\t\t\t"); 1822 1823 objdump_print_value (section->vma - rel_offset + q->address, 1824 inf, TRUE); 1825 1826 if (q->howto == NULL) 1827 printf (": *unknown*\t"); 1828 else if (q->howto->name) 1829 printf (": %s\t", q->howto->name); 1830 else 1831 printf (": %d\t", q->howto->type); 1832 1833 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL) 1834 printf ("*unknown*"); 1835 else 1836 { 1837 const char *sym_name; 1838 1839 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr); 1840 if (sym_name != NULL && *sym_name != '\0') 1841 objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr); 1842 else 1843 { 1844 asection *sym_sec; 1845 1846 sym_sec = bfd_get_section (*q->sym_ptr_ptr); 1847 sym_name = bfd_get_section_name (aux->abfd, sym_sec); 1848 if (sym_name == NULL || *sym_name == '\0') 1849 sym_name = "*unknown*"; 1850 printf ("%s", sym_name); 1851 } 1852 } 1853 1854 if (q->addend) 1855 { 1856 bfd_signed_vma addend = q->addend; 1857 if (addend < 0) 1858 { 1859 printf ("-0x"); 1860 addend = -addend; 1861 } 1862 else 1863 printf ("+0x"); 1864 objdump_print_value (addend, inf, TRUE); 1865 } 1866 1867 printf ("\n"); 1868 need_nl = FALSE; 1869 } 1870 ++(*relppp); 1871 } 1872 1873 if (need_nl) 1874 printf ("\n"); 1875 1876 addr_offset += octets / opb; 1877 } 1878 1879 free (sfile.buffer); 1880 } 1881 1882 static void 1883 disassemble_section (bfd *abfd, asection *section, void *inf) 1884 { 1885 const struct elf_backend_data * bed; 1886 bfd_vma sign_adjust = 0; 1887 struct disassemble_info * pinfo = (struct disassemble_info *) inf; 1888 struct objdump_disasm_info * paux; 1889 unsigned int opb = pinfo->octets_per_byte; 1890 bfd_byte * data = NULL; 1891 bfd_size_type datasize = 0; 1892 arelent ** rel_pp = NULL; 1893 arelent ** rel_ppstart = NULL; 1894 arelent ** rel_ppend; 1895 unsigned long stop_offset; 1896 asymbol * sym = NULL; 1897 long place = 0; 1898 long rel_count; 1899 bfd_vma rel_offset; 1900 unsigned long addr_offset; 1901 1902 /* Sections that do not contain machine 1903 code are not normally disassembled. */ 1904 if (! disassemble_all 1905 && only_list == NULL 1906 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS)) 1907 != (SEC_CODE | SEC_HAS_CONTENTS))) 1908 return; 1909 1910 if (! process_section_p (section)) 1911 return; 1912 1913 datasize = bfd_get_section_size (section); 1914 if (datasize == 0) 1915 return; 1916 1917 /* Decide which set of relocs to use. Load them if necessary. */ 1918 paux = (struct objdump_disasm_info *) pinfo->application_data; 1919 if (paux->dynrelbuf) 1920 { 1921 rel_pp = paux->dynrelbuf; 1922 rel_count = paux->dynrelcount; 1923 /* Dynamic reloc addresses are absolute, non-dynamic are section 1924 relative. REL_OFFSET specifies the reloc address corresponding 1925 to the start of this section. */ 1926 rel_offset = section->vma; 1927 } 1928 else 1929 { 1930 rel_count = 0; 1931 rel_pp = NULL; 1932 rel_offset = 0; 1933 1934 if ((section->flags & SEC_RELOC) != 0 1935 && (dump_reloc_info || pinfo->disassembler_needs_relocs)) 1936 { 1937 long relsize; 1938 1939 relsize = bfd_get_reloc_upper_bound (abfd, section); 1940 if (relsize < 0) 1941 bfd_fatal (bfd_get_filename (abfd)); 1942 1943 if (relsize > 0) 1944 { 1945 rel_ppstart = rel_pp = (arelent **) xmalloc (relsize); 1946 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms); 1947 if (rel_count < 0) 1948 bfd_fatal (bfd_get_filename (abfd)); 1949 1950 /* Sort the relocs by address. */ 1951 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs); 1952 } 1953 } 1954 } 1955 rel_ppend = rel_pp + rel_count; 1956 1957 data = (bfd_byte *) xmalloc (datasize); 1958 1959 bfd_get_section_contents (abfd, section, data, 0, datasize); 1960 1961 paux->sec = section; 1962 pinfo->buffer = data; 1963 pinfo->buffer_vma = section->vma; 1964 pinfo->buffer_length = datasize; 1965 pinfo->section = section; 1966 1967 if (start_address == (bfd_vma) -1 1968 || start_address < pinfo->buffer_vma) 1969 addr_offset = 0; 1970 else 1971 addr_offset = start_address - pinfo->buffer_vma; 1972 1973 if (stop_address == (bfd_vma) -1) 1974 stop_offset = datasize / opb; 1975 else 1976 { 1977 if (stop_address < pinfo->buffer_vma) 1978 stop_offset = 0; 1979 else 1980 stop_offset = stop_address - pinfo->buffer_vma; 1981 if (stop_offset > pinfo->buffer_length / opb) 1982 stop_offset = pinfo->buffer_length / opb; 1983 } 1984 1985 /* Skip over the relocs belonging to addresses below the 1986 start address. */ 1987 while (rel_pp < rel_ppend 1988 && (*rel_pp)->address < rel_offset + addr_offset) 1989 ++rel_pp; 1990 1991 if (addr_offset < stop_offset) 1992 printf (_("\nDisassembly of section %s:\n"), section->name); 1993 1994 /* Find the nearest symbol forwards from our current position. */ 1995 paux->require_sec = TRUE; 1996 sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset, 1997 (struct disassemble_info *) inf, 1998 &place); 1999 paux->require_sec = FALSE; 2000 2001 /* PR 9774: If the target used signed addresses then we must make 2002 sure that we sign extend the value that we calculate for 'addr' 2003 in the loop below. */ 2004 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 2005 && (bed = get_elf_backend_data (abfd)) != NULL 2006 && bed->sign_extend_vma) 2007 sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1); 2008 2009 /* Disassemble a block of instructions up to the address associated with 2010 the symbol we have just found. Then print the symbol and find the 2011 next symbol on. Repeat until we have disassembled the entire section 2012 or we have reached the end of the address range we are interested in. */ 2013 while (addr_offset < stop_offset) 2014 { 2015 bfd_vma addr; 2016 asymbol *nextsym; 2017 unsigned long nextstop_offset; 2018 bfd_boolean insns; 2019 2020 addr = section->vma + addr_offset; 2021 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust; 2022 2023 if (sym != NULL && bfd_asymbol_value (sym) <= addr) 2024 { 2025 int x; 2026 2027 for (x = place; 2028 (x < sorted_symcount 2029 && (bfd_asymbol_value (sorted_syms[x]) <= addr)); 2030 ++x) 2031 continue; 2032 2033 pinfo->symbols = sorted_syms + place; 2034 pinfo->num_symbols = x - place; 2035 pinfo->symtab_pos = place; 2036 } 2037 else 2038 { 2039 pinfo->symbols = NULL; 2040 pinfo->num_symbols = 0; 2041 pinfo->symtab_pos = -1; 2042 } 2043 2044 if (! prefix_addresses) 2045 { 2046 pinfo->fprintf_func (pinfo->stream, "\n"); 2047 objdump_print_addr_with_sym (abfd, section, sym, addr, 2048 pinfo, FALSE); 2049 pinfo->fprintf_func (pinfo->stream, ":\n"); 2050 } 2051 2052 if (sym != NULL && bfd_asymbol_value (sym) > addr) 2053 nextsym = sym; 2054 else if (sym == NULL) 2055 nextsym = NULL; 2056 else 2057 { 2058 #define is_valid_next_sym(SYM) \ 2059 ((SYM)->section == section \ 2060 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \ 2061 && pinfo->symbol_is_valid (SYM, pinfo)) 2062 2063 /* Search forward for the next appropriate symbol in 2064 SECTION. Note that all the symbols are sorted 2065 together into one big array, and that some sections 2066 may have overlapping addresses. */ 2067 while (place < sorted_symcount 2068 && ! is_valid_next_sym (sorted_syms [place])) 2069 ++place; 2070 2071 if (place >= sorted_symcount) 2072 nextsym = NULL; 2073 else 2074 nextsym = sorted_syms[place]; 2075 } 2076 2077 if (sym != NULL && bfd_asymbol_value (sym) > addr) 2078 nextstop_offset = bfd_asymbol_value (sym) - section->vma; 2079 else if (nextsym == NULL) 2080 nextstop_offset = stop_offset; 2081 else 2082 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma; 2083 2084 if (nextstop_offset > stop_offset 2085 || nextstop_offset <= addr_offset) 2086 nextstop_offset = stop_offset; 2087 2088 /* If a symbol is explicitly marked as being an object 2089 rather than a function, just dump the bytes without 2090 disassembling them. */ 2091 if (disassemble_all 2092 || sym == NULL 2093 || sym->section != section 2094 || bfd_asymbol_value (sym) > addr 2095 || ((sym->flags & BSF_OBJECT) == 0 2096 && (strstr (bfd_asymbol_name (sym), "gnu_compiled") 2097 == NULL) 2098 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled") 2099 == NULL)) 2100 || (sym->flags & BSF_FUNCTION) != 0) 2101 insns = TRUE; 2102 else 2103 insns = FALSE; 2104 2105 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data, 2106 addr_offset, nextstop_offset, 2107 rel_offset, &rel_pp, rel_ppend); 2108 2109 addr_offset = nextstop_offset; 2110 sym = nextsym; 2111 } 2112 2113 free (data); 2114 2115 if (rel_ppstart != NULL) 2116 free (rel_ppstart); 2117 } 2118 2119 /* Disassemble the contents of an object file. */ 2120 2121 static void 2122 disassemble_data (bfd *abfd) 2123 { 2124 struct disassemble_info disasm_info; 2125 struct objdump_disasm_info aux; 2126 long i; 2127 2128 print_files = NULL; 2129 prev_functionname = NULL; 2130 prev_line = -1; 2131 prev_discriminator = 0; 2132 2133 /* We make a copy of syms to sort. We don't want to sort syms 2134 because that will screw up the relocs. */ 2135 sorted_symcount = symcount ? symcount : dynsymcount; 2136 sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount) 2137 * sizeof (asymbol *)); 2138 memcpy (sorted_syms, symcount ? syms : dynsyms, 2139 sorted_symcount * sizeof (asymbol *)); 2140 2141 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount); 2142 2143 for (i = 0; i < synthcount; ++i) 2144 { 2145 sorted_syms[sorted_symcount] = synthsyms + i; 2146 ++sorted_symcount; 2147 } 2148 2149 /* Sort the symbols into section and symbol order. */ 2150 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols); 2151 2152 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf); 2153 2154 disasm_info.application_data = (void *) &aux; 2155 aux.abfd = abfd; 2156 aux.require_sec = FALSE; 2157 aux.dynrelbuf = NULL; 2158 aux.dynrelcount = 0; 2159 aux.reloc = NULL; 2160 2161 disasm_info.print_address_func = objdump_print_address; 2162 disasm_info.symbol_at_address_func = objdump_symbol_at_address; 2163 2164 if (machine != NULL) 2165 { 2166 const bfd_arch_info_type *inf = bfd_scan_arch (machine); 2167 2168 if (inf == NULL) 2169 fatal (_("can't use supplied machine %s"), machine); 2170 2171 abfd->arch_info = inf; 2172 } 2173 2174 if (endian != BFD_ENDIAN_UNKNOWN) 2175 { 2176 struct bfd_target *xvec; 2177 2178 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target)); 2179 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target)); 2180 xvec->byteorder = endian; 2181 abfd->xvec = xvec; 2182 } 2183 2184 /* Use libopcodes to locate a suitable disassembler. */ 2185 aux.disassemble_fn = disassembler (abfd); 2186 if (!aux.disassemble_fn) 2187 { 2188 non_fatal (_("can't disassemble for architecture %s\n"), 2189 bfd_printable_arch_mach (bfd_get_arch (abfd), 0)); 2190 exit_status = 1; 2191 return; 2192 } 2193 2194 disasm_info.flavour = bfd_get_flavour (abfd); 2195 disasm_info.arch = bfd_get_arch (abfd); 2196 disasm_info.mach = bfd_get_mach (abfd); 2197 disasm_info.disassembler_options = disassembler_options; 2198 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd); 2199 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES; 2200 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END; 2201 disasm_info.disassembler_needs_relocs = FALSE; 2202 2203 if (bfd_big_endian (abfd)) 2204 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG; 2205 else if (bfd_little_endian (abfd)) 2206 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE; 2207 else 2208 /* ??? Aborting here seems too drastic. We could default to big or little 2209 instead. */ 2210 disasm_info.endian = BFD_ENDIAN_UNKNOWN; 2211 2212 /* Allow the target to customize the info structure. */ 2213 disassemble_init_for_target (& disasm_info); 2214 2215 /* Pre-load the dynamic relocs if we are going 2216 to be dumping them along with the disassembly. */ 2217 if (dump_dynamic_reloc_info) 2218 { 2219 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd); 2220 2221 if (relsize < 0) 2222 bfd_fatal (bfd_get_filename (abfd)); 2223 2224 if (relsize > 0) 2225 { 2226 aux.dynrelbuf = (arelent **) xmalloc (relsize); 2227 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, 2228 aux.dynrelbuf, 2229 dynsyms); 2230 if (aux.dynrelcount < 0) 2231 bfd_fatal (bfd_get_filename (abfd)); 2232 2233 /* Sort the relocs by address. */ 2234 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *), 2235 compare_relocs); 2236 } 2237 } 2238 disasm_info.symtab = sorted_syms; 2239 disasm_info.symtab_size = sorted_symcount; 2240 2241 bfd_map_over_sections (abfd, disassemble_section, & disasm_info); 2242 2243 if (aux.dynrelbuf != NULL) 2244 free (aux.dynrelbuf); 2245 free (sorted_syms); 2246 } 2247 2248 static int 2249 load_specific_debug_section (enum dwarf_section_display_enum debug, 2250 asection *sec, void *file) 2251 { 2252 struct dwarf_section *section = &debug_displays [debug].section; 2253 bfd *abfd = (bfd *) file; 2254 bfd_boolean ret; 2255 2256 /* If it is already loaded, do nothing. */ 2257 if (section->start != NULL) 2258 return 1; 2259 2260 section->address = 0; 2261 section->size = bfd_get_section_size (sec); 2262 section->start = NULL; 2263 ret = bfd_get_full_section_contents (abfd, sec, §ion->start); 2264 2265 if (! ret) 2266 { 2267 free_debug_section (debug); 2268 printf (_("\nCan't get contents for section '%s'.\n"), 2269 section->name); 2270 return 0; 2271 } 2272 2273 if (is_relocatable && debug_displays [debug].relocate) 2274 { 2275 /* We want to relocate the data we've already read (and 2276 decompressed), so we store a pointer to the data in 2277 the bfd_section, and tell it that the contents are 2278 already in memory. */ 2279 sec->contents = section->start; 2280 sec->flags |= SEC_IN_MEMORY; 2281 sec->size = section->size; 2282 2283 ret = bfd_simple_get_relocated_section_contents (abfd, 2284 sec, 2285 section->start, 2286 syms) != NULL; 2287 2288 if (! ret) 2289 { 2290 free_debug_section (debug); 2291 printf (_("\nCan't get contents for section '%s'.\n"), 2292 section->name); 2293 return 0; 2294 } 2295 } 2296 2297 return 1; 2298 } 2299 2300 int 2301 load_debug_section (enum dwarf_section_display_enum debug, void *file) 2302 { 2303 struct dwarf_section *section = &debug_displays [debug].section; 2304 bfd *abfd = (bfd *) file; 2305 asection *sec; 2306 2307 /* If it is already loaded, do nothing. */ 2308 if (section->start != NULL) 2309 return 1; 2310 2311 /* Locate the debug section. */ 2312 sec = bfd_get_section_by_name (abfd, section->uncompressed_name); 2313 if (sec != NULL) 2314 section->name = section->uncompressed_name; 2315 else 2316 { 2317 sec = bfd_get_section_by_name (abfd, section->compressed_name); 2318 if (sec != NULL) 2319 section->name = section->compressed_name; 2320 } 2321 if (sec == NULL) 2322 return 0; 2323 2324 return load_specific_debug_section (debug, sec, file); 2325 } 2326 2327 void 2328 free_debug_section (enum dwarf_section_display_enum debug) 2329 { 2330 struct dwarf_section *section = &debug_displays [debug].section; 2331 2332 if (section->start == NULL) 2333 return; 2334 2335 free ((char *) section->start); 2336 section->start = NULL; 2337 section->address = 0; 2338 section->size = 0; 2339 } 2340 2341 static void 2342 dump_dwarf_section (bfd *abfd, asection *section, 2343 void *arg ATTRIBUTE_UNUSED) 2344 { 2345 const char *name = bfd_get_section_name (abfd, section); 2346 const char *match; 2347 int i; 2348 2349 if (CONST_STRNEQ (name, ".gnu.linkonce.wi.")) 2350 match = ".debug_info"; 2351 else 2352 match = name; 2353 2354 for (i = 0; i < max; i++) 2355 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0 2356 || strcmp (debug_displays [i].section.compressed_name, match) == 0) 2357 && debug_displays [i].enabled != NULL 2358 && *debug_displays [i].enabled) 2359 { 2360 struct dwarf_section *sec = &debug_displays [i].section; 2361 2362 if (strcmp (sec->uncompressed_name, match) == 0) 2363 sec->name = sec->uncompressed_name; 2364 else 2365 sec->name = sec->compressed_name; 2366 if (load_specific_debug_section ((enum dwarf_section_display_enum) i, 2367 section, abfd)) 2368 { 2369 debug_displays [i].display (sec, abfd); 2370 2371 if (i != info && i != abbrev) 2372 free_debug_section ((enum dwarf_section_display_enum) i); 2373 } 2374 break; 2375 } 2376 } 2377 2378 /* Dump the dwarf debugging information. */ 2379 2380 static void 2381 dump_dwarf (bfd *abfd) 2382 { 2383 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0; 2384 2385 eh_addr_size = bfd_arch_bits_per_address (abfd) / 8; 2386 2387 if (bfd_big_endian (abfd)) 2388 byte_get = byte_get_big_endian; 2389 else if (bfd_little_endian (abfd)) 2390 byte_get = byte_get_little_endian; 2391 else 2392 abort (); 2393 2394 switch (bfd_get_arch (abfd)) 2395 { 2396 case bfd_arch_i386: 2397 switch (bfd_get_mach (abfd)) 2398 { 2399 case bfd_mach_x86_64: 2400 case bfd_mach_x86_64_intel_syntax: 2401 case bfd_mach_x64_32: 2402 case bfd_mach_x64_32_intel_syntax: 2403 init_dwarf_regnames_x86_64 (); 2404 break; 2405 2406 default: 2407 init_dwarf_regnames_i386 (); 2408 break; 2409 } 2410 break; 2411 2412 default: 2413 break; 2414 } 2415 2416 bfd_map_over_sections (abfd, dump_dwarf_section, NULL); 2417 2418 free_debug_memory (); 2419 } 2420 2421 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to 2422 it. Return NULL on failure. */ 2423 2424 static char * 2425 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr) 2426 { 2427 asection *stabsect; 2428 bfd_size_type size; 2429 char *contents; 2430 2431 stabsect = bfd_get_section_by_name (abfd, sect_name); 2432 if (stabsect == NULL) 2433 { 2434 printf (_("No %s section present\n\n"), sect_name); 2435 return FALSE; 2436 } 2437 2438 size = bfd_section_size (abfd, stabsect); 2439 contents = (char *) xmalloc (size); 2440 2441 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size)) 2442 { 2443 non_fatal (_("reading %s section of %s failed: %s"), 2444 sect_name, bfd_get_filename (abfd), 2445 bfd_errmsg (bfd_get_error ())); 2446 exit_status = 1; 2447 free (contents); 2448 return NULL; 2449 } 2450 2451 *size_ptr = size; 2452 2453 return contents; 2454 } 2455 2456 /* Stabs entries use a 12 byte format: 2457 4 byte string table index 2458 1 byte stab type 2459 1 byte stab other field 2460 2 byte stab desc field 2461 4 byte stab value 2462 FIXME: This will have to change for a 64 bit object format. */ 2463 2464 #define STRDXOFF (0) 2465 #define TYPEOFF (4) 2466 #define OTHEROFF (5) 2467 #define DESCOFF (6) 2468 #define VALOFF (8) 2469 #define STABSIZE (12) 2470 2471 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'), 2472 using string table section STRSECT_NAME (in `strtab'). */ 2473 2474 static void 2475 print_section_stabs (bfd *abfd, 2476 const char *stabsect_name, 2477 unsigned *string_offset_ptr) 2478 { 2479 int i; 2480 unsigned file_string_table_offset = 0; 2481 unsigned next_file_string_table_offset = *string_offset_ptr; 2482 bfd_byte *stabp, *stabs_end; 2483 2484 stabp = stabs; 2485 stabs_end = stabp + stab_size; 2486 2487 printf (_("Contents of %s section:\n\n"), stabsect_name); 2488 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n"); 2489 2490 /* Loop through all symbols and print them. 2491 2492 We start the index at -1 because there is a dummy symbol on 2493 the front of stabs-in-{coff,elf} sections that supplies sizes. */ 2494 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++) 2495 { 2496 const char *name; 2497 unsigned long strx; 2498 unsigned char type, other; 2499 unsigned short desc; 2500 bfd_vma value; 2501 2502 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF); 2503 type = bfd_h_get_8 (abfd, stabp + TYPEOFF); 2504 other = bfd_h_get_8 (abfd, stabp + OTHEROFF); 2505 desc = bfd_h_get_16 (abfd, stabp + DESCOFF); 2506 value = bfd_h_get_32 (abfd, stabp + VALOFF); 2507 2508 printf ("\n%-6d ", i); 2509 /* Either print the stab name, or, if unnamed, print its number 2510 again (makes consistent formatting for tools like awk). */ 2511 name = bfd_get_stab_name (type); 2512 if (name != NULL) 2513 printf ("%-6s", name); 2514 else if (type == N_UNDF) 2515 printf ("HdrSym"); 2516 else 2517 printf ("%-6d", type); 2518 printf (" %-6d %-6d ", other, desc); 2519 bfd_printf_vma (abfd, value); 2520 printf (" %-6lu", strx); 2521 2522 /* Symbols with type == 0 (N_UNDF) specify the length of the 2523 string table associated with this file. We use that info 2524 to know how to relocate the *next* file's string table indices. */ 2525 if (type == N_UNDF) 2526 { 2527 file_string_table_offset = next_file_string_table_offset; 2528 next_file_string_table_offset += value; 2529 } 2530 else 2531 { 2532 /* Using the (possibly updated) string table offset, print the 2533 string (if any) associated with this symbol. */ 2534 if ((strx + file_string_table_offset) < stabstr_size) 2535 printf (" %s", &strtab[strx + file_string_table_offset]); 2536 else 2537 printf (" *"); 2538 } 2539 } 2540 printf ("\n\n"); 2541 *string_offset_ptr = next_file_string_table_offset; 2542 } 2543 2544 typedef struct 2545 { 2546 const char * section_name; 2547 const char * string_section_name; 2548 unsigned string_offset; 2549 } 2550 stab_section_names; 2551 2552 static void 2553 find_stabs_section (bfd *abfd, asection *section, void *names) 2554 { 2555 int len; 2556 stab_section_names * sought = (stab_section_names *) names; 2557 2558 /* Check for section names for which stabsect_name is a prefix, to 2559 handle .stab.N, etc. */ 2560 len = strlen (sought->section_name); 2561 2562 /* If the prefix matches, and the files section name ends with a 2563 nul or a digit, then we match. I.e., we want either an exact 2564 match or a section followed by a number. */ 2565 if (strncmp (sought->section_name, section->name, len) == 0 2566 && (section->name[len] == 0 2567 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1])))) 2568 { 2569 if (strtab == NULL) 2570 strtab = read_section_stabs (abfd, sought->string_section_name, 2571 &stabstr_size); 2572 2573 if (strtab) 2574 { 2575 stabs = (bfd_byte *) read_section_stabs (abfd, section->name, 2576 &stab_size); 2577 if (stabs) 2578 print_section_stabs (abfd, section->name, &sought->string_offset); 2579 } 2580 } 2581 } 2582 2583 static void 2584 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name) 2585 { 2586 stab_section_names s; 2587 2588 s.section_name = stabsect_name; 2589 s.string_section_name = strsect_name; 2590 s.string_offset = 0; 2591 2592 bfd_map_over_sections (abfd, find_stabs_section, & s); 2593 2594 free (strtab); 2595 strtab = NULL; 2596 } 2597 2598 /* Dump the any sections containing stabs debugging information. */ 2599 2600 static void 2601 dump_stabs (bfd *abfd) 2602 { 2603 dump_stabs_section (abfd, ".stab", ".stabstr"); 2604 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr"); 2605 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr"); 2606 2607 /* For Darwin. */ 2608 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr"); 2609 2610 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$"); 2611 } 2612 2613 static void 2614 dump_bfd_header (bfd *abfd) 2615 { 2616 char *comma = ""; 2617 2618 printf (_("architecture: %s, "), 2619 bfd_printable_arch_mach (bfd_get_arch (abfd), 2620 bfd_get_mach (abfd))); 2621 printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK); 2622 2623 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";} 2624 PF (HAS_RELOC, "HAS_RELOC"); 2625 PF (EXEC_P, "EXEC_P"); 2626 PF (HAS_LINENO, "HAS_LINENO"); 2627 PF (HAS_DEBUG, "HAS_DEBUG"); 2628 PF (HAS_SYMS, "HAS_SYMS"); 2629 PF (HAS_LOCALS, "HAS_LOCALS"); 2630 PF (DYNAMIC, "DYNAMIC"); 2631 PF (WP_TEXT, "WP_TEXT"); 2632 PF (D_PAGED, "D_PAGED"); 2633 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE"); 2634 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE"); 2635 printf (_("\nstart address 0x")); 2636 bfd_printf_vma (abfd, abfd->start_address); 2637 printf ("\n"); 2638 } 2639 2640 2641 static void 2642 dump_bfd_private_header (bfd *abfd) 2643 { 2644 bfd_print_private_bfd_data (abfd, stdout); 2645 } 2646 2647 static void 2648 dump_target_specific (bfd *abfd) 2649 { 2650 const struct objdump_private_desc * const *desc; 2651 struct objdump_private_option *opt; 2652 char *e, *b; 2653 2654 /* Find the desc. */ 2655 for (desc = objdump_private_vectors; *desc != NULL; desc++) 2656 if ((*desc)->filter (abfd)) 2657 break; 2658 2659 if (desc == NULL) 2660 { 2661 non_fatal (_("option -P/--private not supported by this file")); 2662 return; 2663 } 2664 2665 /* Clear all options. */ 2666 for (opt = (*desc)->options; opt->name; opt++) 2667 opt->selected = FALSE; 2668 2669 /* Decode options. */ 2670 b = dump_private_options; 2671 do 2672 { 2673 e = strchr (b, ','); 2674 2675 if (e) 2676 *e = 0; 2677 2678 for (opt = (*desc)->options; opt->name; opt++) 2679 if (strcmp (opt->name, b) == 0) 2680 { 2681 opt->selected = TRUE; 2682 break; 2683 } 2684 if (opt->name == NULL) 2685 non_fatal (_("target specific dump '%s' not supported"), b); 2686 2687 if (e) 2688 { 2689 *e = ','; 2690 b = e + 1; 2691 } 2692 } 2693 while (e != NULL); 2694 2695 /* Dump. */ 2696 (*desc)->dump (abfd); 2697 } 2698 2699 /* Display a section in hexadecimal format with associated characters. 2700 Each line prefixed by the zero padded address. */ 2701 2702 static void 2703 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED) 2704 { 2705 bfd_byte *data = 0; 2706 bfd_size_type datasize; 2707 bfd_size_type addr_offset; 2708 bfd_size_type start_offset; 2709 bfd_size_type stop_offset; 2710 unsigned int opb = bfd_octets_per_byte (abfd); 2711 /* Bytes per line. */ 2712 const int onaline = 16; 2713 char buf[64]; 2714 int count; 2715 int width; 2716 2717 if ((section->flags & SEC_HAS_CONTENTS) == 0) 2718 return; 2719 2720 if (! process_section_p (section)) 2721 return; 2722 2723 if ((datasize = bfd_section_size (abfd, section)) == 0) 2724 return; 2725 2726 /* Compute the address range to display. */ 2727 if (start_address == (bfd_vma) -1 2728 || start_address < section->vma) 2729 start_offset = 0; 2730 else 2731 start_offset = start_address - section->vma; 2732 2733 if (stop_address == (bfd_vma) -1) 2734 stop_offset = datasize / opb; 2735 else 2736 { 2737 if (stop_address < section->vma) 2738 stop_offset = 0; 2739 else 2740 stop_offset = stop_address - section->vma; 2741 2742 if (stop_offset > datasize / opb) 2743 stop_offset = datasize / opb; 2744 } 2745 2746 if (start_offset >= stop_offset) 2747 return; 2748 2749 printf (_("Contents of section %s:"), section->name); 2750 if (display_file_offsets) 2751 printf (_(" (Starting at file offset: 0x%lx)"), 2752 (unsigned long) (section->filepos + start_offset)); 2753 printf ("\n"); 2754 2755 if (!bfd_get_full_section_contents (abfd, section, &data)) 2756 { 2757 non_fatal (_("Reading section failed")); 2758 return; 2759 } 2760 2761 width = 4; 2762 2763 bfd_sprintf_vma (abfd, buf, start_offset + section->vma); 2764 if (strlen (buf) >= sizeof (buf)) 2765 abort (); 2766 2767 count = 0; 2768 while (buf[count] == '0' && buf[count+1] != '\0') 2769 count++; 2770 count = strlen (buf) - count; 2771 if (count > width) 2772 width = count; 2773 2774 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1); 2775 if (strlen (buf) >= sizeof (buf)) 2776 abort (); 2777 2778 count = 0; 2779 while (buf[count] == '0' && buf[count+1] != '\0') 2780 count++; 2781 count = strlen (buf) - count; 2782 if (count > width) 2783 width = count; 2784 2785 for (addr_offset = start_offset; 2786 addr_offset < stop_offset; addr_offset += onaline / opb) 2787 { 2788 bfd_size_type j; 2789 2790 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma)); 2791 count = strlen (buf); 2792 if ((size_t) count >= sizeof (buf)) 2793 abort (); 2794 2795 putchar (' '); 2796 while (count < width) 2797 { 2798 putchar ('0'); 2799 count++; 2800 } 2801 fputs (buf + count - width, stdout); 2802 putchar (' '); 2803 2804 for (j = addr_offset * opb; 2805 j < addr_offset * opb + onaline; j++) 2806 { 2807 if (j < stop_offset * opb) 2808 printf ("%02x", (unsigned) (data[j])); 2809 else 2810 printf (" "); 2811 if ((j & 3) == 3) 2812 printf (" "); 2813 } 2814 2815 printf (" "); 2816 for (j = addr_offset * opb; 2817 j < addr_offset * opb + onaline; j++) 2818 { 2819 if (j >= stop_offset * opb) 2820 printf (" "); 2821 else 2822 printf ("%c", ISPRINT (data[j]) ? data[j] : '.'); 2823 } 2824 putchar ('\n'); 2825 } 2826 free (data); 2827 } 2828 2829 /* Actually display the various requested regions. */ 2830 2831 static void 2832 dump_data (bfd *abfd) 2833 { 2834 bfd_map_over_sections (abfd, dump_section, NULL); 2835 } 2836 2837 /* Should perhaps share code and display with nm? */ 2838 2839 static void 2840 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic) 2841 { 2842 asymbol **current; 2843 long max_count; 2844 long count; 2845 2846 if (dynamic) 2847 { 2848 current = dynsyms; 2849 max_count = dynsymcount; 2850 printf ("DYNAMIC SYMBOL TABLE:\n"); 2851 } 2852 else 2853 { 2854 current = syms; 2855 max_count = symcount; 2856 printf ("SYMBOL TABLE:\n"); 2857 } 2858 2859 if (max_count == 0) 2860 printf (_("no symbols\n")); 2861 2862 for (count = 0; count < max_count; count++) 2863 { 2864 bfd *cur_bfd; 2865 2866 if (*current == NULL) 2867 printf (_("no information for symbol number %ld\n"), count); 2868 2869 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL) 2870 printf (_("could not determine the type of symbol number %ld\n"), 2871 count); 2872 2873 else if (process_section_p ((* current)->section) 2874 && (dump_special_syms 2875 || !bfd_is_target_special_symbol (cur_bfd, *current))) 2876 { 2877 const char *name = (*current)->name; 2878 2879 if (do_demangle && name != NULL && *name != '\0') 2880 { 2881 char *alloc; 2882 2883 /* If we want to demangle the name, we demangle it 2884 here, and temporarily clobber it while calling 2885 bfd_print_symbol. FIXME: This is a gross hack. */ 2886 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS); 2887 if (alloc != NULL) 2888 (*current)->name = alloc; 2889 bfd_print_symbol (cur_bfd, stdout, *current, 2890 bfd_print_symbol_all); 2891 if (alloc != NULL) 2892 { 2893 (*current)->name = name; 2894 free (alloc); 2895 } 2896 } 2897 else 2898 bfd_print_symbol (cur_bfd, stdout, *current, 2899 bfd_print_symbol_all); 2900 printf ("\n"); 2901 } 2902 2903 current++; 2904 } 2905 printf ("\n\n"); 2906 } 2907 2908 static void 2909 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) 2910 { 2911 arelent **p; 2912 char *last_filename, *last_functionname; 2913 unsigned int last_line; 2914 unsigned int last_discriminator; 2915 2916 /* Get column headers lined up reasonably. */ 2917 { 2918 static int width; 2919 2920 if (width == 0) 2921 { 2922 char buf[30]; 2923 2924 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1); 2925 width = strlen (buf) - 7; 2926 } 2927 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, ""); 2928 } 2929 2930 last_filename = NULL; 2931 last_functionname = NULL; 2932 last_line = 0; 2933 last_discriminator = 0; 2934 2935 for (p = relpp; relcount && *p != NULL; p++, relcount--) 2936 { 2937 arelent *q = *p; 2938 const char *filename, *functionname; 2939 unsigned int linenumber; 2940 unsigned int discriminator; 2941 const char *sym_name; 2942 const char *section_name; 2943 bfd_vma addend2 = 0; 2944 2945 if (start_address != (bfd_vma) -1 2946 && q->address < start_address) 2947 continue; 2948 if (stop_address != (bfd_vma) -1 2949 && q->address > stop_address) 2950 continue; 2951 2952 if (with_line_numbers 2953 && sec != NULL 2954 && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address, 2955 &filename, &functionname, 2956 &linenumber, &discriminator)) 2957 { 2958 if (functionname != NULL 2959 && (last_functionname == NULL 2960 || strcmp (functionname, last_functionname) != 0)) 2961 { 2962 printf ("%s():\n", functionname); 2963 if (last_functionname != NULL) 2964 free (last_functionname); 2965 last_functionname = xstrdup (functionname); 2966 } 2967 2968 if (linenumber > 0 2969 && (linenumber != last_line 2970 || (filename != NULL 2971 && last_filename != NULL 2972 && filename_cmp (filename, last_filename) != 0) 2973 || (discriminator != last_discriminator))) 2974 { 2975 if (discriminator > 0) 2976 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber); 2977 else 2978 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename, 2979 linenumber, discriminator); 2980 last_line = linenumber; 2981 last_discriminator = discriminator; 2982 if (last_filename != NULL) 2983 free (last_filename); 2984 if (filename == NULL) 2985 last_filename = NULL; 2986 else 2987 last_filename = xstrdup (filename); 2988 } 2989 } 2990 2991 if (q->sym_ptr_ptr && *q->sym_ptr_ptr) 2992 { 2993 sym_name = (*(q->sym_ptr_ptr))->name; 2994 section_name = (*(q->sym_ptr_ptr))->section->name; 2995 } 2996 else 2997 { 2998 sym_name = NULL; 2999 section_name = NULL; 3000 } 3001 3002 bfd_printf_vma (abfd, q->address); 3003 if (q->howto == NULL) 3004 printf (" *unknown* "); 3005 else if (q->howto->name) 3006 { 3007 const char *name = q->howto->name; 3008 3009 /* R_SPARC_OLO10 relocations contain two addends. 3010 But because 'arelent' lacks enough storage to 3011 store them both, the 64-bit ELF Sparc backend 3012 records this as two relocations. One R_SPARC_LO10 3013 and one R_SPARC_13, both pointing to the same 3014 address. This is merely so that we have some 3015 place to store both addend fields. 3016 3017 Undo this transformation, otherwise the output 3018 will be confusing. */ 3019 if (abfd->xvec->flavour == bfd_target_elf_flavour 3020 && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9 3021 && relcount > 1 3022 && !strcmp (q->howto->name, "R_SPARC_LO10")) 3023 { 3024 arelent *q2 = *(p + 1); 3025 if (q2 != NULL 3026 && q2->howto 3027 && q->address == q2->address 3028 && !strcmp (q2->howto->name, "R_SPARC_13")) 3029 { 3030 name = "R_SPARC_OLO10"; 3031 addend2 = q2->addend; 3032 p++; 3033 } 3034 } 3035 printf (" %-16s ", name); 3036 } 3037 else 3038 printf (" %-16d ", q->howto->type); 3039 3040 if (sym_name) 3041 { 3042 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr); 3043 } 3044 else 3045 { 3046 if (section_name == NULL) 3047 section_name = "*unknown*"; 3048 printf ("[%s]", section_name); 3049 } 3050 3051 if (q->addend) 3052 { 3053 bfd_signed_vma addend = q->addend; 3054 if (addend < 0) 3055 { 3056 printf ("-0x"); 3057 addend = -addend; 3058 } 3059 else 3060 printf ("+0x"); 3061 bfd_printf_vma (abfd, addend); 3062 } 3063 if (addend2) 3064 { 3065 printf ("+0x"); 3066 bfd_printf_vma (abfd, addend2); 3067 } 3068 3069 printf ("\n"); 3070 } 3071 3072 if (last_filename != NULL) 3073 free (last_filename); 3074 if (last_functionname != NULL) 3075 free (last_functionname); 3076 } 3077 3078 static void 3079 dump_relocs_in_section (bfd *abfd, 3080 asection *section, 3081 void *dummy ATTRIBUTE_UNUSED) 3082 { 3083 arelent **relpp; 3084 long relcount; 3085 long relsize; 3086 3087 if ( bfd_is_abs_section (section) 3088 || bfd_is_und_section (section) 3089 || bfd_is_com_section (section) 3090 || (! process_section_p (section)) 3091 || ((section->flags & SEC_RELOC) == 0)) 3092 return; 3093 3094 relsize = bfd_get_reloc_upper_bound (abfd, section); 3095 if (relsize < 0) 3096 bfd_fatal (bfd_get_filename (abfd)); 3097 3098 printf ("RELOCATION RECORDS FOR [%s]:", section->name); 3099 3100 if (relsize == 0) 3101 { 3102 printf (" (none)\n\n"); 3103 return; 3104 } 3105 3106 relpp = (arelent **) xmalloc (relsize); 3107 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms); 3108 3109 if (relcount < 0) 3110 bfd_fatal (bfd_get_filename (abfd)); 3111 else if (relcount == 0) 3112 printf (" (none)\n\n"); 3113 else 3114 { 3115 printf ("\n"); 3116 dump_reloc_set (abfd, section, relpp, relcount); 3117 printf ("\n\n"); 3118 } 3119 free (relpp); 3120 } 3121 3122 static void 3123 dump_relocs (bfd *abfd) 3124 { 3125 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL); 3126 } 3127 3128 static void 3129 dump_dynamic_relocs (bfd *abfd) 3130 { 3131 long relsize; 3132 arelent **relpp; 3133 long relcount; 3134 3135 relsize = bfd_get_dynamic_reloc_upper_bound (abfd); 3136 if (relsize < 0) 3137 bfd_fatal (bfd_get_filename (abfd)); 3138 3139 printf ("DYNAMIC RELOCATION RECORDS"); 3140 3141 if (relsize == 0) 3142 printf (" (none)\n\n"); 3143 else 3144 { 3145 relpp = (arelent **) xmalloc (relsize); 3146 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms); 3147 3148 if (relcount < 0) 3149 bfd_fatal (bfd_get_filename (abfd)); 3150 else if (relcount == 0) 3151 printf (" (none)\n\n"); 3152 else 3153 { 3154 printf ("\n"); 3155 dump_reloc_set (abfd, NULL, relpp, relcount); 3156 printf ("\n\n"); 3157 } 3158 free (relpp); 3159 } 3160 } 3161 3162 /* Creates a table of paths, to search for source files. */ 3163 3164 static void 3165 add_include_path (const char *path) 3166 { 3167 if (path[0] == 0) 3168 return; 3169 include_path_count++; 3170 include_paths = (const char **) 3171 xrealloc (include_paths, include_path_count * sizeof (*include_paths)); 3172 #ifdef HAVE_DOS_BASED_FILE_SYSTEM 3173 if (path[1] == ':' && path[2] == 0) 3174 path = concat (path, ".", (const char *) 0); 3175 #endif 3176 include_paths[include_path_count - 1] = path; 3177 } 3178 3179 static void 3180 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED, 3181 asection *section, 3182 void *arg) 3183 { 3184 if ((section->flags & SEC_DEBUGGING) == 0) 3185 { 3186 bfd_boolean *has_reloc_p = (bfd_boolean *) arg; 3187 section->vma += adjust_section_vma; 3188 if (*has_reloc_p) 3189 section->lma += adjust_section_vma; 3190 } 3191 } 3192 3193 /* Dump selected contents of ABFD. */ 3194 3195 static void 3196 dump_bfd (bfd *abfd) 3197 { 3198 /* If we are adjusting section VMA's, change them all now. Changing 3199 the BFD information is a hack. However, we must do it, or 3200 bfd_find_nearest_line will not do the right thing. */ 3201 if (adjust_section_vma != 0) 3202 { 3203 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC); 3204 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc); 3205 } 3206 3207 if (! dump_debugging_tags && ! suppress_bfd_header) 3208 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd), 3209 abfd->xvec->name); 3210 if (dump_ar_hdrs) 3211 print_arelt_descr (stdout, abfd, TRUE); 3212 if (dump_file_header) 3213 dump_bfd_header (abfd); 3214 if (dump_private_headers) 3215 dump_bfd_private_header (abfd); 3216 if (dump_private_options != NULL) 3217 dump_target_specific (abfd); 3218 if (! dump_debugging_tags && ! suppress_bfd_header) 3219 putchar ('\n'); 3220 if (dump_section_headers) 3221 dump_headers (abfd); 3222 3223 if (dump_symtab 3224 || dump_reloc_info 3225 || disassemble 3226 || dump_debugging 3227 || dump_dwarf_section_info) 3228 syms = slurp_symtab (abfd); 3229 if (dump_dynamic_symtab || dump_dynamic_reloc_info 3230 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0)) 3231 dynsyms = slurp_dynamic_symtab (abfd); 3232 if (disassemble) 3233 { 3234 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms, 3235 dynsymcount, dynsyms, &synthsyms); 3236 if (synthcount < 0) 3237 synthcount = 0; 3238 } 3239 3240 if (dump_symtab) 3241 dump_symbols (abfd, FALSE); 3242 if (dump_dynamic_symtab) 3243 dump_symbols (abfd, TRUE); 3244 if (dump_dwarf_section_info) 3245 dump_dwarf (abfd); 3246 if (dump_stab_section_info) 3247 dump_stabs (abfd); 3248 if (dump_reloc_info && ! disassemble) 3249 dump_relocs (abfd); 3250 if (dump_dynamic_reloc_info && ! disassemble) 3251 dump_dynamic_relocs (abfd); 3252 if (dump_section_contents) 3253 dump_data (abfd); 3254 if (disassemble) 3255 disassemble_data (abfd); 3256 3257 if (dump_debugging) 3258 { 3259 void *dhandle; 3260 3261 dhandle = read_debugging_info (abfd, syms, symcount, TRUE); 3262 if (dhandle != NULL) 3263 { 3264 if (!print_debugging_info (stdout, dhandle, abfd, syms, 3265 bfd_demangle, 3266 dump_debugging_tags ? TRUE : FALSE)) 3267 { 3268 non_fatal (_("%s: printing debugging information failed"), 3269 bfd_get_filename (abfd)); 3270 exit_status = 1; 3271 } 3272 } 3273 /* PR 6483: If there was no STABS or IEEE debug 3274 info in the file, try DWARF instead. */ 3275 else if (! dump_dwarf_section_info) 3276 { 3277 dwarf_select_sections_all (); 3278 dump_dwarf (abfd); 3279 } 3280 } 3281 3282 if (syms) 3283 { 3284 free (syms); 3285 syms = NULL; 3286 } 3287 3288 if (dynsyms) 3289 { 3290 free (dynsyms); 3291 dynsyms = NULL; 3292 } 3293 3294 if (synthsyms) 3295 { 3296 free (synthsyms); 3297 synthsyms = NULL; 3298 } 3299 3300 symcount = 0; 3301 dynsymcount = 0; 3302 synthcount = 0; 3303 } 3304 3305 static void 3306 display_object_bfd (bfd *abfd) 3307 { 3308 char **matching; 3309 3310 if (bfd_check_format_matches (abfd, bfd_object, &matching)) 3311 { 3312 dump_bfd (abfd); 3313 return; 3314 } 3315 3316 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 3317 { 3318 nonfatal (bfd_get_filename (abfd)); 3319 list_matching_formats (matching); 3320 free (matching); 3321 return; 3322 } 3323 3324 if (bfd_get_error () != bfd_error_file_not_recognized) 3325 { 3326 nonfatal (bfd_get_filename (abfd)); 3327 return; 3328 } 3329 3330 if (bfd_check_format_matches (abfd, bfd_core, &matching)) 3331 { 3332 dump_bfd (abfd); 3333 return; 3334 } 3335 3336 nonfatal (bfd_get_filename (abfd)); 3337 3338 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 3339 { 3340 list_matching_formats (matching); 3341 free (matching); 3342 } 3343 } 3344 3345 static void 3346 display_any_bfd (bfd *file, int level) 3347 { 3348 /* Decompress sections unless dumping the section contents. */ 3349 if (!dump_section_contents) 3350 file->flags |= BFD_DECOMPRESS; 3351 3352 /* If the file is an archive, process all of its elements. */ 3353 if (bfd_check_format (file, bfd_archive)) 3354 { 3355 bfd *arfile = NULL; 3356 bfd *last_arfile = NULL; 3357 3358 if (level == 0) 3359 printf (_("In archive %s:\n"), bfd_get_filename (file)); 3360 else 3361 printf (_("In nested archive %s:\n"), bfd_get_filename (file)); 3362 3363 for (;;) 3364 { 3365 bfd_set_error (bfd_error_no_error); 3366 3367 arfile = bfd_openr_next_archived_file (file, arfile); 3368 if (arfile == NULL) 3369 { 3370 if (bfd_get_error () != bfd_error_no_more_archived_files) 3371 nonfatal (bfd_get_filename (file)); 3372 break; 3373 } 3374 3375 display_any_bfd (arfile, level + 1); 3376 3377 if (last_arfile != NULL) 3378 bfd_close (last_arfile); 3379 last_arfile = arfile; 3380 } 3381 3382 if (last_arfile != NULL) 3383 bfd_close (last_arfile); 3384 } 3385 else 3386 display_object_bfd (file); 3387 } 3388 3389 static void 3390 display_file (char *filename, char *target) 3391 { 3392 bfd *file; 3393 3394 if (get_file_size (filename) < 1) 3395 { 3396 exit_status = 1; 3397 return; 3398 } 3399 3400 file = bfd_openr (filename, target); 3401 if (file == NULL) 3402 { 3403 nonfatal (filename); 3404 return; 3405 } 3406 3407 display_any_bfd (file, 0); 3408 3409 bfd_close (file); 3410 } 3411 3412 int 3413 main (int argc, char **argv) 3414 { 3415 int c; 3416 char *target = default_target; 3417 bfd_boolean seenflag = FALSE; 3418 3419 #if defined (HAVE_SETLOCALE) 3420 #if defined (HAVE_LC_MESSAGES) 3421 setlocale (LC_MESSAGES, ""); 3422 #endif 3423 setlocale (LC_CTYPE, ""); 3424 #endif 3425 3426 bindtextdomain (PACKAGE, LOCALEDIR); 3427 textdomain (PACKAGE); 3428 3429 program_name = *argv; 3430 xmalloc_set_program_name (program_name); 3431 3432 START_PROGRESS (program_name, 0); 3433 3434 expandargv (&argc, &argv); 3435 3436 bfd_init (); 3437 set_default_bfd_target (); 3438 3439 while ((c = getopt_long (argc, argv, 3440 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::", 3441 long_options, (int *) 0)) 3442 != EOF) 3443 { 3444 switch (c) 3445 { 3446 case 0: 3447 break; /* We've been given a long option. */ 3448 case 'm': 3449 machine = optarg; 3450 break; 3451 case 'M': 3452 if (disassembler_options) 3453 /* Ignore potential memory leak for now. */ 3454 disassembler_options = concat (disassembler_options, ",", 3455 optarg, (const char *) NULL); 3456 else 3457 disassembler_options = optarg; 3458 break; 3459 case 'j': 3460 add_only (optarg); 3461 break; 3462 case 'F': 3463 display_file_offsets = TRUE; 3464 break; 3465 case 'l': 3466 with_line_numbers = TRUE; 3467 break; 3468 case 'b': 3469 target = optarg; 3470 break; 3471 case 'C': 3472 do_demangle = TRUE; 3473 if (optarg != NULL) 3474 { 3475 enum demangling_styles style; 3476 3477 style = cplus_demangle_name_to_style (optarg); 3478 if (style == unknown_demangling) 3479 fatal (_("unknown demangling style `%s'"), 3480 optarg); 3481 3482 cplus_demangle_set_style (style); 3483 } 3484 break; 3485 case 'w': 3486 wide_output = TRUE; 3487 break; 3488 case OPTION_ADJUST_VMA: 3489 adjust_section_vma = parse_vma (optarg, "--adjust-vma"); 3490 break; 3491 case OPTION_START_ADDRESS: 3492 start_address = parse_vma (optarg, "--start-address"); 3493 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address) 3494 fatal (_("error: the start address should be before the end address")); 3495 break; 3496 case OPTION_STOP_ADDRESS: 3497 stop_address = parse_vma (optarg, "--stop-address"); 3498 if ((start_address != (bfd_vma) -1) && stop_address <= start_address) 3499 fatal (_("error: the stop address should be after the start address")); 3500 break; 3501 case OPTION_PREFIX: 3502 prefix = optarg; 3503 prefix_length = strlen (prefix); 3504 /* Remove an unnecessary trailing '/' */ 3505 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1])) 3506 prefix_length--; 3507 break; 3508 case OPTION_PREFIX_STRIP: 3509 prefix_strip = atoi (optarg); 3510 if (prefix_strip < 0) 3511 fatal (_("error: prefix strip must be non-negative")); 3512 break; 3513 case OPTION_INSN_WIDTH: 3514 insn_width = strtoul (optarg, NULL, 0); 3515 if (insn_width <= 0) 3516 fatal (_("error: instruction width must be positive")); 3517 break; 3518 case 'E': 3519 if (strcmp (optarg, "B") == 0) 3520 endian = BFD_ENDIAN_BIG; 3521 else if (strcmp (optarg, "L") == 0) 3522 endian = BFD_ENDIAN_LITTLE; 3523 else 3524 { 3525 nonfatal (_("unrecognized -E option")); 3526 usage (stderr, 1); 3527 } 3528 break; 3529 case OPTION_ENDIAN: 3530 if (strncmp (optarg, "big", strlen (optarg)) == 0) 3531 endian = BFD_ENDIAN_BIG; 3532 else if (strncmp (optarg, "little", strlen (optarg)) == 0) 3533 endian = BFD_ENDIAN_LITTLE; 3534 else 3535 { 3536 non_fatal (_("unrecognized --endian type `%s'"), optarg); 3537 exit_status = 1; 3538 usage (stderr, 1); 3539 } 3540 break; 3541 3542 case 'f': 3543 dump_file_header = TRUE; 3544 seenflag = TRUE; 3545 break; 3546 case 'i': 3547 formats_info = TRUE; 3548 seenflag = TRUE; 3549 break; 3550 case 'I': 3551 add_include_path (optarg); 3552 break; 3553 case 'p': 3554 dump_private_headers = TRUE; 3555 seenflag = TRUE; 3556 break; 3557 case 'P': 3558 dump_private_options = optarg; 3559 seenflag = TRUE; 3560 break; 3561 case 'x': 3562 dump_private_headers = TRUE; 3563 dump_symtab = TRUE; 3564 dump_reloc_info = TRUE; 3565 dump_file_header = TRUE; 3566 dump_ar_hdrs = TRUE; 3567 dump_section_headers = TRUE; 3568 seenflag = TRUE; 3569 break; 3570 case 't': 3571 dump_symtab = TRUE; 3572 seenflag = TRUE; 3573 break; 3574 case 'T': 3575 dump_dynamic_symtab = TRUE; 3576 seenflag = TRUE; 3577 break; 3578 case 'd': 3579 disassemble = TRUE; 3580 seenflag = TRUE; 3581 break; 3582 case 'z': 3583 disassemble_zeroes = TRUE; 3584 break; 3585 case 'D': 3586 disassemble = TRUE; 3587 disassemble_all = TRUE; 3588 seenflag = TRUE; 3589 break; 3590 case 'S': 3591 disassemble = TRUE; 3592 with_source_code = TRUE; 3593 seenflag = TRUE; 3594 break; 3595 case 'g': 3596 dump_debugging = 1; 3597 seenflag = TRUE; 3598 break; 3599 case 'e': 3600 dump_debugging = 1; 3601 dump_debugging_tags = 1; 3602 do_demangle = TRUE; 3603 seenflag = TRUE; 3604 break; 3605 case 'W': 3606 dump_dwarf_section_info = TRUE; 3607 seenflag = TRUE; 3608 if (optarg) 3609 dwarf_select_sections_by_letters (optarg); 3610 else 3611 dwarf_select_sections_all (); 3612 break; 3613 case OPTION_DWARF: 3614 dump_dwarf_section_info = TRUE; 3615 seenflag = TRUE; 3616 if (optarg) 3617 dwarf_select_sections_by_names (optarg); 3618 else 3619 dwarf_select_sections_all (); 3620 break; 3621 case OPTION_DWARF_DEPTH: 3622 { 3623 char *cp; 3624 dwarf_cutoff_level = strtoul (optarg, & cp, 0); 3625 } 3626 break; 3627 case OPTION_DWARF_START: 3628 { 3629 char *cp; 3630 dwarf_start_die = strtoul (optarg, & cp, 0); 3631 suppress_bfd_header = 1; 3632 } 3633 break; 3634 case OPTION_DWARF_CHECK: 3635 dwarf_check = TRUE; 3636 break; 3637 case 'G': 3638 dump_stab_section_info = TRUE; 3639 seenflag = TRUE; 3640 break; 3641 case 's': 3642 dump_section_contents = TRUE; 3643 seenflag = TRUE; 3644 break; 3645 case 'r': 3646 dump_reloc_info = TRUE; 3647 seenflag = TRUE; 3648 break; 3649 case 'R': 3650 dump_dynamic_reloc_info = TRUE; 3651 seenflag = TRUE; 3652 break; 3653 case 'a': 3654 dump_ar_hdrs = TRUE; 3655 seenflag = TRUE; 3656 break; 3657 case 'h': 3658 dump_section_headers = TRUE; 3659 seenflag = TRUE; 3660 break; 3661 case 'H': 3662 usage (stdout, 0); 3663 seenflag = TRUE; 3664 case 'v': 3665 case 'V': 3666 show_version = TRUE; 3667 seenflag = TRUE; 3668 break; 3669 3670 default: 3671 usage (stderr, 1); 3672 } 3673 } 3674 3675 if (show_version) 3676 print_version ("objdump"); 3677 3678 if (!seenflag) 3679 usage (stderr, 2); 3680 3681 if (formats_info) 3682 exit_status = display_info (); 3683 else 3684 { 3685 if (optind == argc) 3686 display_file ("a.out", target); 3687 else 3688 for (; optind < argc;) 3689 display_file (argv[optind++], target); 3690 } 3691 3692 free_only_list (); 3693 3694 END_PROGRESS (program_name); 3695 3696 return exit_status; 3697 } 3698