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