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