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