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