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